diff --git a/docs/tutorials/13 - US Spatial Analysis for US Si & CdTe/1 - PCA baselines for Si & CdTe.ipynb b/docs/tutorials/13 - US Spatial Analysis for US Si & CdTe/1 - PCA baselines for Si & CdTe.ipynb new file mode 100644 index 0000000..e70a4b7 --- /dev/null +++ b/docs/tutorials/13 - US Spatial Analysis for US Si & CdTe/1 - PCA baselines for Si & CdTe.ipynb @@ -0,0 +1,700 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# REEDs PCA Baselines for Si & CdTe" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ReEDS installation projections from the Solar Futures Study, published by DOE on 2021.\n", + "\n", + "Scenario Interest: \n", + "o\t95-by-35+Elec.Adv+DR , a.k.a. \"Solar Futures Decarbonization + Electrification scenario\"\n", + "\n", + "This code performs three Methods to output files for the Mass Flows:\n", + "
    \n", + "
  1. PCA original data by ReEDS
  2. \n", + "
  3. PCA data reordered based on ascending production up to 2035, and then descending,
  4. \n", + "
  5. PCA data calculated with an exponencial that mathces the cumulative 2035 and 2050 targets
  6. \n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import PV_ICE\n", + "import numpy as np\n", + "import pandas as pd\n", + "import os,sys\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.rcParams.update({'font.size': 22})\n", + "plt.rcParams['figure.figsize'] = (12, 8)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your simulation will be stored in C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\docs\\tutorials\\13 - US Spatial Analysis for US Si & CdTe\\TEMP\n" + ] + } + ], + "source": [ + "import os\n", + "from pathlib import Path\n", + "\n", + "cwd = os.getcwd()\n", + "testfolder = os.path.join(cwd, 'TEMP')\n", + "\n", + "if not os.path.exists(testfolder):\n", + " os.makedirs(testfolder)\n", + "print (\"Your simulation will be stored in %s\" % testfolder)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Working on a Windows 10\n", + "Python version 3.11.7 | packaged by Anaconda, Inc. | (main, Dec 15 2023, 18:05:47) [MSC v.1916 64 bit (AMD64)]\n", + "Pandas version 2.1.0\n", + "PV_ICE version 0.3.4+7.g5a5d2dc.dirty\n" + ] + } + ], + "source": [ + "# This information helps with debugging and getting support :)\n", + "import sys, platform\n", + "print(\"Working on a \", platform.system(), platform.release())\n", + "print(\"Python version \", sys.version)\n", + "print(\"Pandas version \", pd.__version__)\n", + "print(\"PV_ICE version \", PV_ICE.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "WindowsPath('C:/Users/sayala/Documents/GitHub/PV_ICE/PV_ICE/baselines')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "baselinesFolder = Path().resolve().parent.parent.parent / 'PV_ICE' / 'baselines'\n", + "baselinesFolder" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Create Scenarios" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A. Reading a standard ReEDS output file" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input file is stored in C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\baselines\\SupportingMaterial\\December Core Scenarios ReEDS Outputs Solar Futures v3a.xlsx\n" + ] + } + ], + "source": [ + "reedsFile = os.path.join(baselinesFolder, 'SupportingMaterial', 'December Core Scenarios ReEDS Outputs Solar Futures v3a.xlsx')\n", + "print (\"Input file is stored in %s\" % reedsFile)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "REEDSInput = pd.read_excel(reedsFile,\n", + "# sheet_name=\"new installs PV (2)\")\n", + " sheet_name=\"new installs PV\")\n", + "\n", + "#index_col=[0,2,3]) #this casts scenario, PCA and State as levels\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### B. Save Input Files by PCA" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Create a copy of the REEDS Input and modify structure for PCA focus" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Capacity (GW)
ScenarioYearPCA
95-by-35.Adv2010p10.000017
2011p10.005158
2012p10.005158
2013p10.007146
2014p10.007146
2015p10.018253
2016p10.018253
2017p10.019460
2018p10.019460
2019p10.036320
2020p10.036320
2021p10.002434
2022p10.002434
2023p10.010066
2024p10.010066
2025p10.049445
2026p10.049445
2027p10.051342
2028p10.051342
2029p10.105931
2030p10.105931
\n", + "
" + ], + "text/plain": [ + " Capacity (GW)\n", + "Scenario Year PCA \n", + "95-by-35.Adv 2010 p1 0.000017\n", + " 2011 p1 0.005158\n", + " 2012 p1 0.005158\n", + " 2013 p1 0.007146\n", + " 2014 p1 0.007146\n", + " 2015 p1 0.018253\n", + " 2016 p1 0.018253\n", + " 2017 p1 0.019460\n", + " 2018 p1 0.019460\n", + " 2019 p1 0.036320\n", + " 2020 p1 0.036320\n", + " 2021 p1 0.002434\n", + " 2022 p1 0.002434\n", + " 2023 p1 0.010066\n", + " 2024 p1 0.010066\n", + " 2025 p1 0.049445\n", + " 2026 p1 0.049445\n", + " 2027 p1 0.051342\n", + " 2028 p1 0.051342\n", + " 2029 p1 0.105931\n", + " 2030 p1 0.105931" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rawdf = REEDSInput.copy()\n", + "rawdf.drop(columns=['State'], inplace=True)\n", + "rawdf.drop(columns=['Tech'], inplace=True) #tech=pvtotal from \"new installs PV sheet\", so can drop\n", + "rawdf.set_index(['Scenario','Year','PCA'], inplace=True)\n", + "rawdf.head(21)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "#### Loading Module Baseline. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "path = C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\docs\\tutorials\\13 - US Spatial Analysis for US Si & CdTe\\TEMP\n", + "Baseline folder directed to default: C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\baselines\n" + ] + } + ], + "source": [ + "r1 = PV_ICE.Simulation(name='Simulation1', path=testfolder)\n", + "r1.createScenario(name='cSi', massmodulefile= 'baseline_modules_mass_US.csv', energymodulefile='baseline_modules_energy.csv') # this is technically cSi, but we haven't renamed the baseline.\n", + "baseline = r1.scenario['cSi'].dataIn_m\n", + "baseline = baseline.drop(columns=['new_Installed_Capacity_[MW]'])\n", + "baseline.set_index('year', inplace=True)\n", + "baseline.index = pd.PeriodIndex(baseline.index, freq='A') # A -- Annual\n", + "baseline.head()\n", + "\n", + "r1.createScenario(name='CdTe', massmodulefile='baseline_modules_mass_US_CdTe.csv', energymodulefile='baseline_modules_energy.csv')\n", + "baselineCdTe = r1.scenario['CdTe'].dataIn_m\n", + "baselineCdTe = baselineCdTe.drop(columns=['new_Installed_Capacity_[MW]'])\n", + "baselineCdTe.set_index('year', inplace=True)\n", + "baselineCdTe.index = pd.PeriodIndex(baselineCdTe.index, freq='A') # A -- Annual" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "r1.scenMod_noCircularity() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### For each Scenario and for each PCA, combine with baseline and save as input file" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "#### Set header dynamically\n", + "import csv\n", + "\n", + "massmodulefile = os.path.join(baselinesFolder, 'baseline_modules_mass_US.csv')\n", + "\n", + "with open(massmodulefile, newline='') as f:\n", + " reader = csv.reader(f)\n", + " row1 = next(reader) # gets the first line\n", + " row2 = next(reader) # gets the first line\n", + "\n", + "row11 = 'year'\n", + "for x in row1[1:]:\n", + " row11 = row11 + ',' + x \n", + "\n", + "row22 = 'year'\n", + "for x in row2[1:]:\n", + " row22 = row22 + ',' + x " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Load MarketShare File" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "marketsharefile = os.path.join(baselinesFolder,'SupportingMaterial','output_USA_Si_marketshare.csv')\n", + "marketshare = pd.read_csv(marketsharefile)\n", + "marketshare = marketshare[marketshare['Year']>=2010].reset_index(drop=True)\n", + "marketshare.set_index('Year', inplace=True)\n", + "marketshare.rename(columns={'All_Marketshare':'cSi Market Share'}, inplace=True)\n", + "marketshare.loc[2021:,'cSi Market Share'] = 0.81 # Values only go to 2020 at the moment; setting fixed value to same as 2020\n", + "marketshare['CdTe Market Share'] = 1 - marketshare['cSi Market Share']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "# Hack for plots.\n", + "sparkplot = True\n", + "xvals = ['2010', '2011', '2012', '2013', '2014', '2015', '2016', '2017',\n", + " '2018', '2019', '2020', '2021', '2022', '2023', '2024', '2025',\n", + " '2026', '2027', '2028', '2029', '2030', '2031', '2032', '2033',\n", + " '2034', '2035', '2036', '2037', '2038', '2039', '2040', '2041',\n", + " '2042', '2043', '2044', '2045', '2046', '2047', '2048', '2049',\n", + " '2050']\n", + "plt.rcParams.update({'font.size': 8})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Methods to smooth projected capacity increases:\n", + "1. Method 1: Uses the raw regionalized capacity by ReEEDS, this creates a very uneven peak of wastes.\n", + "2. Method 2: Uses ordered wastes between 2021 to 2035 and 2046 to 2050. Still creates unrealistic peaks.\n", + "3. Method 3: Uses the cummulative capacity between 2021 to 2035 and 2034 to 2050 to create a logarithmic growth of waste (this method is being tested, not validated yet, and subjected to ongoing changes)." + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "Method = 1 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Non explored methods \n", + "\n", + " Method 4: \n", + "\n", + "Create a monotonically increasing deployment based on the cumulative betwen 2022 to 2035, and 2036 to 2050.\n", + "\n", + "First calculates the cumulatives, then normalizes by 105 (for 14 years monotonically increasing) or 120 (for 15 years monotonically increasing), and then it does a loop to calculate each year\n" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "for ii in range (len(rawdf.unstack(level=1))):\n", + " PCA = rawdf.unstack(level=1).iloc[ii].name[1] #This one iterates over the pca names: p1 to p99\n", + " SCEN = rawdf.unstack(level=1).iloc[ii].name[0] #This one iterates over all scenario names: \n", + " # 95-by-35+Elec.Adv, 95-by-35.Adv, Reference.Adv+DR, etc\n", + " SCEN=SCEN.replace('+', '_')\n", + " filetitle = SCEN+'_cSI_'+PCA +'.csv' #These lines, 2 to 5 will allow to make file names\n", + " subtestfolder = os.path.join(b, 'PCAs_Method1') # Create folder of the scenarios\n", + " if not os.path.exists(subtestfolder): # Create folder if it doen's exist\n", + " os.makedirs(subtestfolder)\n", + " filetitle = os.path.join(subtestfolder, filetitle)\n", + " A = rawdf.unstack(level=1).iloc[ii]\n", + " A = A.droplevel(level=0)\n", + " A.name = 'new_Installed_Capacity_[MW]'\n", + " A = pd.DataFrame(A)\n", + " A.index=pd.PeriodIndex(A.index, freq='A')\n", + " A = pd.DataFrame(A)\n", + " B = A.copy()\n", + " B['new_Installed_Capacity_[MW]'] = B['new_Installed_Capacity_[MW]'] * marketshare['cSi Market Share'].values\n", + " B['new_Installed_Capacity_[MW]'] = B['new_Installed_Capacity_[MW]'] * 1000 # ReEDS file is in GW.\n", + "\n", + " if Method == 2:\n", + " # Sort Ascending 2022 to 2035 new_Installed_Capacity_[MW]\n", + " # Sort Descending 2035 to 2050 new_Installed_Capacity_[MW]\n", + " sortedB = (list(B.iloc[0:12]['new_Installed_Capacity_[MW]'].values) + list(B.iloc[12:25]['new_Installed_Capacity_[MW]'].sort_values().values)\n", + " +list(B.iloc[25::]['new_Installed_Capacity_[MW]'].sort_values(ascending=False).values))\n", + " sortedBdf = pd.DataFrame(sortedB, index = A.index, columns =['new_Installed_Capacity_[MW]'])\n", + " B = sortedBdf.reindex(A.index)\n", + " elif Method == 3: \n", + " # LINEAR\n", + " # some sort of exponential growth that still sums up tthe correct capacity would be ideal.\n", + " # Currently jsut doing a linear division per year per location\n", + " # LINEAR\n", + " yearly2035 = B.iloc[12:26]['new_Installed_Capacity_[MW]'].sum()/len(B.iloc[12:26])\n", + " yearly2050 = B.iloc[26::]['new_Installed_Capacity_[MW]'].sum()/len(B.iloc[26::])\n", + " n2022= B.iloc[12].name\n", + " n2035= B.iloc[25].name\n", + " n2036= B.iloc[26].name\n", + " n2050= B.iloc[-1].name\n", + " B.loc[n2022:n2035, 'new_Installed_Capacity_[MW]' ] = yearly2035\n", + " B.loc[n2036:n2050, 'new_Installed_Capacity_[MW]' ] = yearly2050\n", + "\n", + " # Add other columns\n", + " B = pd.concat([B, baseline.reindex(A.index)], axis=1)\n", + " \n", + " header = row11 + '\\n' + row22 + '\\n'\n", + " \n", + " # SPARK PLOT\n", + " if sparkplot:\n", + " sparkplotfolder = os.path.join(subtestfolder, 'SPARKPLOTS')\n", + " if not os.path.exists(sparkplotfolder):\n", + " os.makedirs(sparkplotfolder)\n", + "\n", + " fig, axs = plt.subplots(figsize=(8, 5), facecolor='w', edgecolor='k')\n", + " plt.plot(xvals, B['new_Installed_Capacity_[MW]'].values)\n", + " plt.xticks(rotation=45)\n", + " figtitle = 'PV ICE ' + SCEN + ' Baseline_Csi_'+PCA+'.png'\n", + " fig.savefig(os.path.join(sparkplotfolder, figtitle), dpi=600)\n", + " plt.close(fig) # This avoids the figure from displayig and getting all the warnings\n", + " \n", + " with open(filetitle, 'w', newline='') as ict:\n", + " # Write the header lines, including the index variable for\n", + " # the last one if you're letting Pandas produce that for you.\n", + " # (see above).\n", + " for line in header:\n", + " ict.write(line)\n", + "\n", + " # savedata.to_csv(ict, index=False)\n", + " B.to_csv(ict, header=False)\n", + " \n", + " filetitle = SCEN+'_CdTe_'+PCA +'.csv'\n", + " filetitle = os.path.join(subtestfolder, filetitle)\n", + "\n", + " B = A.copy()\n", + " B['new_Installed_Capacity_[MW]'] = B['new_Installed_Capacity_[MW]'] * marketshare['CdTe Market Share'].values\n", + " B['new_Installed_Capacity_[MW]'] = B['new_Installed_Capacity_[MW]'] * 1000 # ReEDS file is in GW.\n", + " if Method == 2:\n", + " sortedB = (list(B.iloc[0:12]['new_Installed_Capacity_[MW]'].values) + list(B.iloc[12:25]['new_Installed_Capacity_[MW]'].sort_values().values)\n", + " +list(B.iloc[25::]['new_Installed_Capacity_[MW]'].sort_values(ascending=False).values))\n", + " sortedBdf = pd.DataFrame(sortedB, index = A.index, columns =['new_Installed_Capacity_[MW]'])\n", + " B = sortedBdf.reindex(A.index)\n", + " elif Method == 3: \n", + " # LINEAR\n", + " # some sort of exponential growth that still sums up tthe correct capacity would be ideal.\n", + " # Currently jsut doing a linear division per year per location\n", + " # LINEAR\n", + " yearly2035 = B.iloc[12:26]['new_Installed_Capacity_[MW]'].sum()/len(B.iloc[12:26])\n", + " yearly2050 = B.iloc[26::]['new_Installed_Capacity_[MW]'].sum()/len(B.iloc[26::])\n", + " n2022= B.iloc[12].name\n", + " n2035= B.iloc[25].name\n", + " n2036= B.iloc[26].name\n", + " n2050= B.iloc[-1].name\n", + " B.loc[n2022:n2035, 'new_Installed_Capacity_[MW]' ] = yearly2035\n", + " B.loc[n2036:n2050, 'new_Installed_Capacity_[MW]' ] = yearly2050\n", + " \n", + " # Add other columns\n", + " B = pd.concat([B, baseline.reindex(A.index)], axis=1)\n", + " \n", + " with open(filetitle, 'w', newline='') as ict:\n", + " # Write the header lines, including the index variable for\n", + " # the last one if you're letting Pandas produce that for you.\n", + " # (see above).\n", + " for line in header:\n", + " ict.write(line)\n", + "\n", + " # savedata.to_csv(ict, index=False)\n", + " B.to_csv(ict, header=False)\n", + "\n", + "print(\"Results saved on \", testfolder)" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)\n", + "Other options based on this method: \n", + "* increasing o the cumulative between 2022 to 2050 --> divide by 435 instead and set kk to loop 0 to 29 \n", + "* Or increasing between 2022 to 2035, and decreasing for 2036 to 2050 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Method 5: (Heather) \n", + "\n" + ] + }, + { + "cell_type": "raw", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "scrolled": true + }, + "source": [ + "# DUmmy code\n", + "rom scipy.optimize import curve_fit\n", + "# Function to calculate the power-law with constants a and b\n", + "\n", + "def power_law(x, a, b):\n", + " return a*np.power(x, b)\n", + " \n", + "#generae a dataset for the area in between\n", + "mod_eff_late = mod_eff_raw.loc[(mod_eff_raw.index>=2020)]\n", + "\n", + "y_dummy = power_law(mod_eff_late.index-2019, mod_eff_late['mod_eff'][2020], 0.065) #17.9\n", + "#played around with the exponential until y_dummy[31] closely matched projected 25.06% value. CITE\n", + "print(y_dummy[-1])\n", + "plt.plot(y_dummy)#create a dataframe of the projection\n", + "\n", + "mod_eff_late['mod_eff'] = y_dummy\n", + "#print(mod_eff_late)\n", + "plt.plot(mod_eff_late)\n", + "#mod_eff_late.to_csv(cwd+'/../../../PV_ICE/baselines/SupportingMaterial/output_module_eff_perovskite.csv', index=True)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/tutorials/13 - US Spatial Analysis for US Si & CdTe/2 - MassFlows Calculations.ipynb b/docs/tutorials/13 - US Spatial Analysis for US Si & CdTe/2 - MassFlows Calculations.ipynb new file mode 100644 index 0000000..5d77948 --- /dev/null +++ b/docs/tutorials/13 - US Spatial Analysis for US Si & CdTe/2 - MassFlows Calculations.ipynb @@ -0,0 +1,25951 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "dc9d045c-d008-478c-a0c1-3a3bb0bb68d3", + "metadata": {}, + "source": [ + "# MassFlows Calculations" + ] + }, + { + "cell_type": "markdown", + "id": "e7f7ac91-b821-428d-937e-7ed7364ef95b", + "metadata": {}, + "source": [ + "## 1. Initial setup" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6e869c19-6f92-40db-a041-57784774127a", + "metadata": {}, + "outputs": [], + "source": [ + "import PV_ICE\n", + "import numpy as np\n", + "import pandas as pd\n", + "import os,sys\n", + "import matplotlib.pyplot as plt\n", + "from pathlib import Path\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9d235534-0bb4-46e6-b58f-05e35f1db616", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your simulation will be stored in C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\docs\\tutorials\\13 - US Spatial Analysis for US Si & CdTe\\TEMP\n" + ] + } + ], + "source": [ + "testfolder = os.path.join(cwd, 'TEMP')\n", + "print (\"Your simulation will be stored in %s\" % testfolder)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ffb7c852-d156-494f-8a79-a35f804c923d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "WindowsPath('C:/Users/sayala/Documents/GitHub/PV_ICE/PV_ICE/baselines')" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "baselinesFolder = Path().resolve().parent.parent.parent / 'PV_ICE' / 'baselines'\n", + "baselinesFolder" + ] + }, + { + "cell_type": "markdown", + "id": "69e15609-ea32-483b-8286-9b88b4a943e8", + "metadata": {}, + "source": [ + "### Reading GIS inputs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "368e6ec8-6a75-41de-becd-bae8519ccca4", + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'geopy'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[5], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeopy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mgeocoders\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Nominatim\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeopy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpoint\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Point\n\u001b[0;32m 3\u001b[0m \u001b[38;5;66;03m# initialize Nominatim API\u001b[39;00m\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'geopy'" + ] + } + ], + "source": [ + "from geopy.geocoders import Nominatim\n", + "from geopy.point import Point\n", + "# initialize Nominatim API\n", + "geolocator = Nominatim(user_agent=\"geoapiExercises\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "46b1d9e5-19f6-40f5-badd-1918f7983772", + "metadata": {}, + "outputs": [], + "source": [ + "GISfile = os.path.join(baselinesFolder, 'SupportingMaterial','gis_centroid_n.csv')\n", + "GIS = pd.read_csv(GISfile)\n", + "GIS = GIS.set_index('id')" + ] + }, + { + "cell_type": "markdown", + "id": "91f80c80-2fc5-4d8c-817c-bc25400cc53c", + "metadata": {}, + "source": [ + "## 2. Load PCA baselines, create the 2 Scenarios and assign baselines\n", + "\n", + "Keeping track of each scenario as its own PV ICE Object." + ] + }, + { + "cell_type": "markdown", + "id": "c1407225-8467-4e33-ae37-ddb9886ccab0", + "metadata": {}, + "source": [ + "Select the method folder you want to run (uncomment your choice). There are three choices:\n", + "1. Method 1: Uses the raw regionalized capacity by ReEEDS, this creates a very uneven peak of wastes.\n", + "2. Method 2: Uses ordered wastes between 2021 to 2035 and 2046 to 2050. Still creates unrealistic peaks.\n", + "3. Method 3: Uses the cummulative capacity between 2021 to 2035 and 2034 to 2050 to create a logarithmic growth of waste (this method is being tested, not validated yet, and subjected to ongoing changes)." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "cf92be8e-cfa9-4508-89f4-4ead033b1ee0", + "metadata": {}, + "outputs": [], + "source": [ + "projectionmethod = 'Method1'" + ] + }, + { + "cell_type": "markdown", + "id": "dfeab2fc-7fdb-4ab1-9828-2f1779ce558f", + "metadata": {}, + "source": [ + "### Scenario creation" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "91a88bc4-3081-4c05-8f81-c7f1063e0c00", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input file is stored in C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\baselines\\SupportingMaterial\\December Core Scenarios ReEDS Outputs Solar Futures v3a.xlsx\n" + ] + } + ], + "source": [ + "reedsFile = os.path.join(baselinesFolder, 'SupportingMaterial','December Core Scenarios ReEDS Outputs Solar Futures v3a.xlsx')\n", + "print (\"Input file is stored in %s\" % reedsFile)\n", + "REEDSInput = pd.read_excel(reedsFile, sheet_name=\"new installs PV\")\n", + "rawdf = REEDSInput.copy()\n", + "rawdf.drop(columns=['State'], inplace=True)\n", + "rawdf.drop(columns=['Tech'], inplace=True) #tech=pvtotal from \"new installs PV sheet\", so can drop\n", + "rawdf.set_index(['Scenario','Year','PCA'], inplace=True)\n", + "PCAs = list(rawdf.unstack(level=2).iloc[0].unstack(level=0).index.unique())" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "350cb479-f961-44f8-8cac-0389939b0323", + "metadata": {}, + "outputs": [], + "source": [ + "SFscenarios = ['95-by-35_Elec.Adv_DR_cSi', '95-by-35_Elec.Adv_DR_CdTe']" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "1632821a-01e5-4e1a-b8b2-29d705b01625", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "path = C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\docs\\tutorials\\13 - US Spatial Analysis for US Si & CdTe\\TEMP\n", + "Baseline folder directed to default: C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\baselines\n" + ] + } + ], + "source": [ + "i = 0\n", + "r1 = PV_ICE.Simulation(name=SFscenarios[i], path=testfolder)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "5f83b94c-16e6-471a-bf28-65bafea1220d", + "metadata": {}, + "outputs": [], + "source": [ + "jj=0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d3e64f70-3181-49d0-99b1-b937c7b574db", + "metadata": {}, + "outputs": [], + "source": [ + "massmodulefile" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "111afdb4-0378-4b90-a30b-6535ae87ed96", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No energy module file passed. If desired, pass one of the following options: ['baseline_modules_energy.csv']\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n" + ] + } + ], + "source": [ + "filetitle = SFscenarios[i]+'_'+PCAs[jj]+'.csv'\n", + "filetitle = os.path.join(testfolder, f'PCAs_{projectionmethod}', filetitle) # Change this number to the simulation you want to run\n", + "r1.createScenario(name=PCAs[jj], massmodulefile=filetitle)\n", + "r1.scenario[PCAs[jj]].addMaterials(['glass', 'silicon', 'silver', 'copper', 'aluminium_frames', 'encapsulant', 'backsheet'], )\n", + "r1.scenario[PCAs[jj]].latitude = GIS.loc[PCAs[jj]].lat\n", + "r1.scenario[PCAs[jj]].longitude = GIS.loc[PCAs[jj]].long" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "ba99629d-4022-4ec3-8a09-9123a63582e8", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "path = C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\docs\\tutorials\\13 - US Spatial Analysis for US Si & CdTe\\TEMP\n", + "Baseline folder directed to default: C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\baselines\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Adding Mass AND Energy files for: glass\n", + "Adding Mass AND Energy files for: silicon\n", + "Adding Mass AND Energy files for: silver\n", + "Adding Mass AND Energy files for: copper\n", + "Adding Mass AND Energy files for: aluminium_frames\n", + "Adding Mass AND Energy files for: encapsulant\n", + "Adding Mass AND Energy files for: backsheet\n", + "Trimming and extending p1\n", + "p1 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p1 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p1 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p1 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p1 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p1 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p1 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p1 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p10\n", + "p10 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p10 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p10 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p10 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p10 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p10 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p10 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p10 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p100\n", + "p100 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p100 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p100 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p100 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p100 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p100 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p100 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p100 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p101\n", + "p101 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p101 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p101 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p101 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p101 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p101 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p101 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p101 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p102\n", + "p102 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p102 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p102 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p102 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p102 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p102 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p102 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p102 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p103\n", + "p103 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p103 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p103 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p103 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p103 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p103 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p103 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p103 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p104\n", + "p104 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p104 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p104 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p104 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p104 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p104 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p104 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p104 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p105\n", + "p105 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p105 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p105 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p105 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p105 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p105 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p105 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p105 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p106\n", + "p106 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p106 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p106 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p106 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p106 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p106 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p106 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p106 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p107\n", + "p107 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p107 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p107 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p107 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p107 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p107 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p107 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p107 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p108\n", + "p108 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p108 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p108 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p108 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p108 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p108 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p108 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p108 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p109\n", + "p109 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p109 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p109 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p109 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p109 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p109 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p109 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p109 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p11\n", + "p11 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p11 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p11 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p11 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p11 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p11 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p11 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p11 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p110\n", + "p110 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p110 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p110 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p110 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p110 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p110 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p110 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p110 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p111\n", + "p111 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p111 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p111 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p111 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p111 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p111 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p111 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p111 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p112\n", + "p112 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p112 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p112 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p112 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p112 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p112 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p112 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p112 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p113\n", + "p113 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p113 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p113 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p113 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p113 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p113 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p113 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p113 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p114\n", + "p114 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p114 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p114 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p114 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p114 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p114 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p114 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p114 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p115\n", + "p115 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p115 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p115 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p115 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p115 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p115 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p115 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p115 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p116\n", + "p116 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p116 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p116 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p116 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p116 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p116 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p116 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p116 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p117\n", + "p117 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p117 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p117 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p117 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p117 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p117 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p117 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p117 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p118\n", + "p118 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p118 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p118 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p118 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p118 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p118 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p118 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p118 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p119\n", + "p119 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p119 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p119 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p119 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p119 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p119 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p119 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p119 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p12\n", + "p12 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p12 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p12 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p12 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p12 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p12 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p12 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p12 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p120\n", + "p120 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p120 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p120 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p120 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p120 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p120 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p120 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p120 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p121\n", + "p121 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p121 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p121 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p121 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p121 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p121 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p121 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p121 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p122\n", + "p122 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p122 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p122 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p122 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p122 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p122 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p122 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p122 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p123\n", + "p123 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p123 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p123 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p123 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p123 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p123 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p123 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p123 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p124\n", + "p124 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p124 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p124 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p124 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p124 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p124 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p124 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p124 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p125\n", + "p125 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p125 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p125 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p125 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p125 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p125 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p125 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p125 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p126\n", + "p126 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p126 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p126 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p126 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p126 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p126 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p126 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p126 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p127\n", + "p127 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p127 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p127 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p127 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p127 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p127 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p127 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p127 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p128\n", + "p128 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p128 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p128 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p128 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p128 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p128 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p128 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p128 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p129\n", + "p129 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p129 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p129 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p129 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p129 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p129 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p129 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p129 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p13\n", + "p13 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p13 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p13 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p13 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p13 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p13 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p13 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p13 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p130\n", + "p130 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p130 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p130 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p130 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p130 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p130 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p130 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p130 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p131\n", + "p131 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p131 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p131 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p131 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p131 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p131 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p131 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p131 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p132\n", + "p132 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p132 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p132 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p132 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p132 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p132 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p132 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p132 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p133\n", + "p133 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p133 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p133 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p133 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p133 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p133 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p133 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p133 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p134\n", + "p134 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p134 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p134 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p134 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p134 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p134 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p134 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p134 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p14\n", + "p14 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p14 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p14 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p14 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p14 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p14 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p14 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p14 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p15\n", + "p15 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p15 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p15 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p15 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p15 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p15 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p15 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p15 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p16\n", + "p16 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p16 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p16 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p16 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p16 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p16 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p16 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p16 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p17\n", + "p17 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p17 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p17 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p17 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p17 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p17 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p17 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p17 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p18\n", + "p18 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p18 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p18 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p18 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p18 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p18 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p18 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p18 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p19\n", + "p19 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p19 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p19 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p19 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p19 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p19 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p19 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p19 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p2\n", + "p2 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p2 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p2 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p2 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p2 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p2 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p2 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p2 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p20\n", + "p20 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p20 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p20 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p20 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p20 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p20 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p20 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p20 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p21\n", + "p21 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p21 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p21 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p21 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p21 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p21 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p21 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p21 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p22\n", + "p22 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p22 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p22 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p22 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p22 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p22 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p22 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p22 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p23\n", + "p23 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p23 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p23 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p23 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p23 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p23 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p23 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p23 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p24\n", + "p24 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p24 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p24 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p24 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p24 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p24 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p24 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p24 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p25\n", + "p25 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p25 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p25 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p25 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p25 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p25 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p25 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p25 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p26\n", + "p26 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p26 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p26 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p26 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p26 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p26 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p26 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p26 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p27\n", + "p27 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p27 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p27 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p27 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p27 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p27 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p27 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p27 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p28\n", + "p28 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p28 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p28 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p28 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p28 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p28 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p28 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p28 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p29\n", + "p29 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p29 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p29 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p29 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p29 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p29 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p29 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p29 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p3\n", + "p3 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p3 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p3 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p3 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p3 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p3 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p3 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p3 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p30\n", + "p30 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p30 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p30 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p30 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p30 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p30 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p30 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p30 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p31\n", + "p31 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p31 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p31 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p31 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p31 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p31 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p31 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p31 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p32\n", + "p32 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p32 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p32 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p32 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p32 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p32 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p32 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p32 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p33\n", + "p33 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p33 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p33 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p33 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p33 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p33 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p33 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p33 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p34\n", + "p34 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p34 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p34 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p34 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p34 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p34 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p34 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p34 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p35\n", + "p35 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p35 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p35 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p35 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p35 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p35 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p35 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p35 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p36\n", + "p36 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p36 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p36 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p36 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p36 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p36 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p36 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p36 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p37\n", + "p37 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p37 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p37 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p37 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p37 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p37 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p37 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p37 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p38\n", + "p38 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p38 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p38 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p38 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p38 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p38 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p38 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p38 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p39\n", + "p39 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p39 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p39 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p39 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p39 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p39 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p39 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p39 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p4\n", + "p4 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p4 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p4 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p4 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p4 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p4 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p4 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p4 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p40\n", + "p40 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p40 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p40 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p40 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p40 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p40 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p40 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p40 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p41\n", + "p41 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p41 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p41 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p41 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p41 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p41 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p41 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p41 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p42\n", + "p42 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p42 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p42 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p42 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p42 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p42 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p42 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p42 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p43\n", + "p43 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p43 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p43 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p43 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p43 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p43 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p43 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p43 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p44\n", + "p44 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p44 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p44 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p44 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p44 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p44 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p44 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p44 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p45\n", + "p45 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p45 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p45 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p45 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p45 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p45 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p45 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p45 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p46\n", + "p46 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p46 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p46 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p46 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p46 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p46 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p46 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p46 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p47\n", + "p47 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p47 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p47 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p47 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p47 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p47 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p47 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p47 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p48\n", + "p48 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p48 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p48 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p48 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p48 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p48 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p48 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p48 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p49\n", + "p49 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p49 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p49 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p49 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p49 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p49 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p49 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p49 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p5\n", + "p5 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p5 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p5 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p5 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p5 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p5 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p5 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p5 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p50\n", + "p50 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p50 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p50 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p50 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p50 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p50 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p50 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p50 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p51\n", + "p51 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p51 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p51 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p51 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p51 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p51 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p51 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p51 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p52\n", + "p52 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p52 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p52 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p52 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p52 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p52 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p52 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p52 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p53\n", + "p53 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p53 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p53 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p53 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p53 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p53 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p53 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p53 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p54\n", + "p54 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p54 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p54 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p54 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p54 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p54 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p54 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p54 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p55\n", + "p55 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p55 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p55 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p55 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p55 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p55 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p55 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p55 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p56\n", + "p56 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p56 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p56 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p56 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p56 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p56 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p56 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p56 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p57\n", + "p57 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p57 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p57 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p57 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p57 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p57 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p57 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p57 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p58\n", + "p58 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p58 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p58 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p58 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p58 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p58 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p58 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p58 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p59\n", + "p59 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p59 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p59 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p59 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p59 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p59 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p59 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p59 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p6\n", + "p6 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p6 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p6 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p6 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p6 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p6 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p6 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p6 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p60\n", + "p60 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p60 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p60 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p60 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p60 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p60 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p60 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p60 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p61\n", + "p61 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p61 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p61 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p61 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p61 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p61 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p61 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p61 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p62\n", + "p62 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p62 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p62 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p62 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p62 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p62 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p62 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p62 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p63\n", + "p63 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p63 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p63 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p63 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p63 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p63 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p63 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p63 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p64\n", + "p64 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p64 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p64 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p64 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p64 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p64 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p64 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p64 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p65\n", + "p65 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p65 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p65 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p65 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p65 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p65 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p65 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p65 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p66\n", + "p66 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p66 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p66 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p66 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p66 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p66 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p66 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p66 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p67\n", + "p67 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p67 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p67 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p67 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p67 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p67 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p67 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p67 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p68\n", + "p68 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p68 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p68 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p68 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p68 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p68 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p68 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p68 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p69\n", + "p69 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p69 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p69 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p69 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p69 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p69 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p69 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p69 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p7\n", + "p7 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p7 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p7 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p7 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p7 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p7 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p7 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p7 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p70\n", + "p70 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p70 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p70 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p70 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p70 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p70 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p70 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p70 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p71\n", + "p71 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p71 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p71 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p71 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p71 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p71 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p71 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p71 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p72\n", + "p72 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p72 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p72 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p72 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p72 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p72 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p72 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p72 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p73\n", + "p73 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p73 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p73 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p73 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p73 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p73 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p73 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p73 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p74\n", + "p74 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p74 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p74 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p74 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p74 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p74 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p74 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p74 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p75\n", + "p75 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p75 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p75 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p75 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p75 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p75 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p75 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p75 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p76\n", + "p76 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p76 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p76 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p76 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p76 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p76 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p76 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p76 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p77\n", + "p77 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p77 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p77 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p77 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p77 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p77 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p77 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p77 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p78\n", + "p78 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p78 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p78 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p78 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p78 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p78 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p78 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p78 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p79\n", + "p79 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p79 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p79 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p79 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p79 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p79 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p79 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p79 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p8\n", + "p8 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p8 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p8 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p8 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p8 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p8 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p8 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p8 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p80\n", + "p80 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p80 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p80 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p80 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p80 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p80 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p80 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p80 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p81\n", + "p81 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p81 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p81 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p81 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p81 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p81 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p81 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p81 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p82\n", + "p82 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p82 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p82 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p82 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p82 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p82 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p82 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p82 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p83\n", + "p83 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p83 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p83 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p83 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p83 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p83 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p83 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p83 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p84\n", + "p84 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p84 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p84 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p84 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p84 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p84 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p84 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p84 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p85\n", + "p85 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p85 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p85 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p85 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p85 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p85 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p85 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p85 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p86\n", + "p86 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p86 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p86 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p86 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p86 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p86 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p86 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p86 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p87\n", + "p87 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p87 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p87 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p87 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p87 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p87 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p87 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p87 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p88\n", + "p88 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p88 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p88 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p88 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p88 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p88 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p88 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p88 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p89\n", + "p89 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p89 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p89 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p89 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p89 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p89 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p89 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p89 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p9\n", + "p9 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p9 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p9 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p9 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p9 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p9 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p9 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p9 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p90\n", + "p90 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p90 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p90 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p90 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p90 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p90 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p90 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p90 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p91\n", + "p91 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p91 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p91 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p91 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p91 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p91 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p91 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p91 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p92\n", + "p92 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p92 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p92 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p92 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p92 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p92 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p92 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p92 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p93\n", + "p93 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p93 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p93 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p93 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p93 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p93 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p93 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p93 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p94\n", + "p94 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p94 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p94 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p94 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p94 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p94 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p94 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p94 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p95\n", + "p95 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p95 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p95 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p95 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p95 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p95 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p95 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p95 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p96\n", + "p96 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p96 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p96 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p96 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p96 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p96 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p96 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p96 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p97\n", + "p97 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p97 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p97 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p97 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p97 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p97 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p97 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p97 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p98\n", + "p98 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p98 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p98 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p98 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p98 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p98 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p98 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p98 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p99\n", + "p99 glass : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p99 silicon : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p99 silver : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p99 copper : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p99 aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p99 encapsulant : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p99 backsheet : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p99 backsheet : Data trimmed for Mass, years now encompass 2010 to 2050\n" + ] + } + ], + "source": [ + "#for ii in range (0, 1): #len(scenarios):\n", + "i = 0\n", + "r1 = PV_ICE.Simulation(name=SFscenarios[i], path=testfolder)\n", + "\n", + "for jj in range (0, len(PCAs)): \n", + " filetitle = SFscenarios[i]+'_'+PCAs[jj]+'.csv'\n", + " filetitle = os.path.join(testfolder, f'PCAs_{projectionmethod}', filetitle) # Change this number to the simulation you want to run\n", + " r1.createScenario(name=PCAs[jj], massmodulefile=filetitle, energymodulefile='baseline_modules_energy.csv')\n", + " r1.scenario[PCAs[jj]].addMaterials(['glass', 'silicon', 'silver', 'copper', 'aluminium_frames', 'encapsulant', 'backsheet'])\n", + " r1.scenario[PCAs[jj]].latitude = GIS.loc[PCAs[jj]].lat\n", + " r1.scenario[PCAs[jj]].longitude = GIS.loc[PCAs[jj]].long\n", + "\n", + "r1.trim_Years(startYear=2010, endYear=2050)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "9bc4ba00-7429-4e26-be07-bd41de10b9e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "path = C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\docs\\tutorials\\13 - US Spatial Analysis for US Si & CdTe\\TEMP\n", + "Baseline folder directed to default: C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\baselines\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Adding Mass AND Energy files for: cadmium\n", + "Adding Mass AND Energy files for: tellurium\n", + "Adding Mass files for: glass_cdte\n", + "Adding Mass files for: aluminium_frames_cdte\n", + "Adding Mass files for: encapsulant_cdte\n", + "Adding Mass files for: copper_cdte\n", + "Trimming and extending p1\n", + "p1 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p1 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p1 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p10\n", + "p10 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p10 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p10 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p100\n", + "p100 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p100 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p100 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p101\n", + "p101 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p101 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p101 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p102\n", + "p102 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p102 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p102 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p103\n", + "p103 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p103 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p103 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p104\n", + "p104 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p104 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p104 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p105\n", + "p105 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p105 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p105 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p106\n", + "p106 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p106 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p106 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p107\n", + "p107 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p107 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p107 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p108\n", + "p108 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p108 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p108 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p109\n", + "p109 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p109 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p109 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p11\n", + "p11 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p11 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p11 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p110\n", + "p110 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p110 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p110 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p111\n", + "p111 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p111 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p111 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p112\n", + "p112 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p112 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p112 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p113\n", + "p113 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p113 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p113 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p114\n", + "p114 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p114 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p114 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p115\n", + "p115 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p115 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p115 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p116\n", + "p116 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p116 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p116 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p117\n", + "p117 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p117 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p117 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p118\n", + "p118 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p118 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p118 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p119\n", + "p119 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p119 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p119 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p12\n", + "p12 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p12 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p12 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p120\n", + "p120 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p120 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p120 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p121\n", + "p121 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p121 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p121 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p122\n", + "p122 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p122 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p122 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p123\n", + "p123 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p123 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p123 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p124\n", + "p124 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p124 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p124 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p125\n", + "p125 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p125 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p125 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p126\n", + "p126 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p126 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p126 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p127\n", + "p127 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p127 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p127 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p128\n", + "p128 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p128 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p128 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p129\n", + "p129 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p129 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p129 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p13\n", + "p13 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p13 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p13 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p130\n", + "p130 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p130 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p130 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p131\n", + "p131 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p131 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p131 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p132\n", + "p132 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p132 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p132 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p133\n", + "p133 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p133 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p133 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p134\n", + "p134 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p134 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p134 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p14\n", + "p14 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p14 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p14 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p15\n", + "p15 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p15 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p15 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p16\n", + "p16 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p16 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p16 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p17\n", + "p17 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p17 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p17 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p18\n", + "p18 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p18 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p18 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p19\n", + "p19 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p19 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p19 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p2\n", + "p2 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p2 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p2 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p20\n", + "p20 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p20 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p20 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p21\n", + "p21 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p21 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p21 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p22\n", + "p22 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p22 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p22 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p23\n", + "p23 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p23 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p23 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p24\n", + "p24 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p24 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p24 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p25\n", + "p25 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p25 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p25 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p26\n", + "p26 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p26 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p26 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p27\n", + "p27 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p27 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p27 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p28\n", + "p28 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p28 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p28 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p29\n", + "p29 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p29 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p29 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p3\n", + "p3 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p3 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p3 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p30\n", + "p30 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p30 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p30 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p31\n", + "p31 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p31 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p31 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p32\n", + "p32 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p32 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p32 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p33\n", + "p33 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p33 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p33 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p34\n", + "p34 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p34 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p34 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p35\n", + "p35 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p35 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p35 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p36\n", + "p36 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p36 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p36 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p37\n", + "p37 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p37 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p37 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p38\n", + "p38 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p38 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p38 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p39\n", + "p39 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p39 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p39 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p4\n", + "p4 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p4 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p4 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p40\n", + "p40 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p40 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p40 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p41\n", + "p41 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p41 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p41 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p42\n", + "p42 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p42 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p42 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p43\n", + "p43 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p43 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p43 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p44\n", + "p44 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p44 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p44 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p45\n", + "p45 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p45 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p45 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p46\n", + "p46 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p46 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p46 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p47\n", + "p47 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p47 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p47 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p48\n", + "p48 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p48 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p48 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p49\n", + "p49 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p49 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p49 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p5\n", + "p5 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p5 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p5 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p50\n", + "p50 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p50 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p50 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p51\n", + "p51 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p51 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p51 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p52\n", + "p52 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p52 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p52 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p53\n", + "p53 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p53 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p53 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p54\n", + "p54 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p54 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p54 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p55\n", + "p55 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p55 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p55 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p56\n", + "p56 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p56 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p56 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p57\n", + "p57 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p57 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p57 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p58\n", + "p58 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p58 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p58 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p59\n", + "p59 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p59 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p59 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p6\n", + "p6 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p6 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p6 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p60\n", + "p60 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p60 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p60 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p61\n", + "p61 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p61 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p61 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p62\n", + "p62 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p62 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p62 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p63\n", + "p63 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p63 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p63 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p64\n", + "p64 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p64 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p64 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p65\n", + "p65 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p65 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p65 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p66\n", + "p66 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p66 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p66 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p67\n", + "p67 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p67 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p67 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p68\n", + "p68 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p68 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p68 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p69\n", + "p69 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p69 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p69 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p7\n", + "p7 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p7 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p7 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p70\n", + "p70 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p70 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p70 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p71\n", + "p71 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p71 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p71 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p72\n", + "p72 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p72 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p72 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p73\n", + "p73 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p73 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p73 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p74\n", + "p74 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p74 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p74 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p75\n", + "p75 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p75 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p75 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p76\n", + "p76 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p76 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p76 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p77\n", + "p77 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p77 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p77 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p78\n", + "p78 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p78 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p78 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p79\n", + "p79 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p79 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p79 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p8\n", + "p8 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p8 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p8 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p80\n", + "p80 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p80 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p80 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p81\n", + "p81 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p81 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p81 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p82\n", + "p82 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p82 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p82 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p83\n", + "p83 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p83 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p83 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p84\n", + "p84 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p84 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p84 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p85\n", + "p85 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p85 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p85 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p86\n", + "p86 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p86 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p86 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p87\n", + "p87 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p87 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p87 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p88\n", + "p88 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p88 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p88 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p89\n", + "p89 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p89 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p89 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p9\n", + "p9 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p9 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p9 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p90\n", + "p90 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p90 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p90 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p91\n", + "p91 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p91 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p91 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p92\n", + "p92 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p92 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p92 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p93\n", + "p93 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p93 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p93 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p94\n", + "p94 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p94 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p94 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p95\n", + "p95 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p95 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p95 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p96\n", + "p96 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p96 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p96 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p97\n", + "p97 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p97 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p97 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p98\n", + "p98 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p98 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p98 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n", + "Trimming and extending p99\n", + "p99 cadmium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "p99 tellurium : Data trimmed for Energy, years now encompass 2010 to 2050\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "No material energy data loaded.\n", + "p99 copper_cdte : Data trimmed for Mass, years now encompass 2010 to 2050\n" + ] + } + ], + "source": [ + "i = 1\n", + "r2 = PV_ICE.Simulation(name=SFscenarios[i], path=testfolder)\n", + "\n", + "for jj in range (0, len(PCAs)): \n", + " filetitle = SFscenarios[i]+'_'+PCAs[jj]+'.csv'\n", + " filetitle = os.path.join(testfolder, f'PCAs_{projectionmethod}', filetitle) \n", + " r2.createScenario(name=PCAs[jj], massmodulefile=filetitle, energymodulefile='baseline_modules_energy.csv')\n", + " r2.scenario[PCAs[jj]].addMaterials(['cadmium', 'tellurium', 'glass_cdte', 'aluminium_frames_cdte', 'encapsulant_cdte', 'copper_cdte'])\n", + " r2.scenario[PCAs[jj]].latitude = GIS.loc[PCAs[jj]].lat\n", + " r2.scenario[PCAs[jj]].longitude = GIS.loc[PCAs[jj]].long\n", + "\n", + "r2.trim_Years(startYear=2010, endYear=2050)\n" + ] + }, + { + "cell_type": "markdown", + "id": "d9ded322-4338-4000-a21a-d9d6be1d754a", + "metadata": {}, + "source": [ + "### Set characteristics for Manufacturing \n", + "IF only EoL needed, set manufacturing waste to 0 by running PercetManufacturing() modifying scenario function" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "2a2f635a-bd8e-4b6f-8ed9-a4d8cc651c18", + "metadata": {}, + "outputs": [], + "source": [ + "PERFECTMFG = True\n", + "# Set to false if I want to see how much goes to mnf waste\n", + "if PERFECTMFG:\n", + " r1.scenMod_PerfectManufacturing()\n", + " r2.scenMod_PerfectManufacturing()\n", + " title_Method = 'PVICE_PerfectMFG'\n", + "else:\n", + " title_Method = 'PVICE'" + ] + }, + { + "cell_type": "markdown", + "id": "9cc3b26a-d1cc-4ab1-b3f3-867d2beab8d0", + "metadata": {}, + "source": [ + "## 3. Calculate Mass Flow" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "fd36dd96-2af4-425b-b2b0-9f7c76e0c9d2", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">>>> Calculating Material Flows <<<<\n", + "\n", + "Working on Scenario: p1\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p10\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p100\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p101\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p102\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p103\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p104\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p105\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p106\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p107\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p108\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p109\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p11\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p110\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p111\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p112\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p113\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p114\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p115\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p116\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p117\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p118\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p119\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p12\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p120\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p121\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p122\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p123\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "Recycled surplus End of Sim for Mat aluminium_frames Scenario p123 = 198.409544030397 tonnes.\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p124\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p125\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p126\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p127\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p128\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p129\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p13\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p130\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p131\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p132\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p133\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p134\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p14\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p15\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p16\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p17\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p18\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p19\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p2\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p20\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p21\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p22\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p23\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p24\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p25\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p26\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p27\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "Recycled surplus End of Sim for Mat aluminium_frames Scenario p27 = 22.203202724022894 tonnes.\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p28\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p29\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p3\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p30\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p31\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p32\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p33\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p34\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p35\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p36\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p37\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p38\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p39\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p4\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p40\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p41\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p42\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p43\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p44\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p45\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p46\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p47\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p48\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p49\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p5\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p50\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p51\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p52\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p53\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p54\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p55\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p56\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p57\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p58\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p59\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p6\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p60\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "Recycled surplus End of Sim for Mat aluminium_frames Scenario p60 = 41.93857005456588 tonnes.\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p61\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "Recycled surplus End of Sim for Mat aluminium_frames Scenario p61 = 63.73968814224483 tonnes.\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p62\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "Recycled surplus End of Sim for Mat aluminium_frames Scenario p62 = 66.16547542916032 tonnes.\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p63\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p64\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p65\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p66\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p67\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p68\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p69\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p7\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p70\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p71\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p72\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p73\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p74\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p75\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p76\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p77\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p78\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p79\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p8\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p80\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p81\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p82\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "Recycled surplus End of Sim for Mat aluminium_frames Scenario p82 = 38.4183419262878 tonnes.\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p83\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "Recycled surplus End of Sim for Mat aluminium_frames Scenario p83 = 10.539098093614433 tonnes.\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p84\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p85\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p86\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p87\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p88\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p89\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p9\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p90\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p91\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p92\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p93\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p94\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p95\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p96\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p97\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p98\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n", + "Working on Scenario: p99\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : glass\n", + "==> Working on Material : silicon\n", + "==> Working on Material : silver\n", + "==> Working on Material : copper\n", + "==> Working on Material : aluminium_frames\n", + "==> Working on Material : encapsulant\n", + "==> Working on Material : backsheet\n" + ] + } + ], + "source": [ + "r1.calculateMassFlow()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "b43cb74d-4c7d-4ff8-be8f-838a6504da39", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">>>> Calculating Material Flows <<<<\n", + "\n", + "Working on Scenario: p1\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p1 = 4.2840613273360955 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p10\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p10 = 56.20817241187791 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p100\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p100 = 0.12050895602676151 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p101\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p101 = 29.48905826694197 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p102\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p102 = 27.396627965518736 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p103\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p103 = 11.191943003931142 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p104\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p104 = 0.20310023668425287 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p105\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p105 = 0.7914757022873259 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p106\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p106 = 15.325115975210412 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p107\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p107 = 0.6302510995441215 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p108\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p108 = 0.1205751806684325 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p109\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p109 = 1.7069764026754006 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p11\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p11 = 8.426432623761846 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p110\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p110 = 0.004451694960256264 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p111\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p111 = 0.3728035152143907 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p112\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p112 = 1.5889403407367964 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p113\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p113 = 0.23067472741221826 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p114\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p114 = 3.7714961270552374 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p115\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p115 = 0.7823510722415524 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p116\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p116 = 0.2781260663102875 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p117\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p117 = 0.14117345238820136 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p118\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p118 = 0.39573499246748006 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p119\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p119 = 0.07168082714025173 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p12\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p12 = 5.910345227356916 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p120\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p120 = 0.04192889305382376 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p121\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p121 = 0.7212254418130352 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p122\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p122 = 3.7617169730816364 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p123\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p123 = 74.30911408095471 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p124\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p124 = 0.030739615540742633 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p125\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p125 = 0.46681907360357944 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p126\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p126 = 7.28861895646272 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p127\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p127 = 12.745524249781948 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p128\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p128 = 2.5634929819612964 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p129\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p129 = 0.5384281567626001 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p13\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p13 = 7.711578511367762 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p130\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p130 = 0.3775851424076408 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p131\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p131 = 4.019251782223468 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p132\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p132 = 10.218369094405922 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p133\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p133 = 1.1890009312252225 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p134\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p134 = 1.4437120741425238 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p14\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p14 = 0.10959801212631086 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p15\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p15 = 0.5271607396543867 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p16\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p16 = 1.131860483544535 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p17\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p17 = 0.029981701606475446 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p18\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p18 = 0.042868018592259124 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p19\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p19 = 0.0006353562633778839 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p2\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p2 = 0.11119028552548336 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p20\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p20 = 0.019891101099394876 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p21\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p21 = 0.1304623279619016 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p22\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p22 = 0.002491833633051836 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p23\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p23 = 0.10760120677845472 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p24\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p24 = 0.020604416649818536 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p25\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p25 = 5.488464478986381 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p26\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p26 = 0.5929488389814646 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p27\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p27 = 23.919148202184925 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p28\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p28 = 4.753044387870787 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p29\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p29 = 0.009856580690322645 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p3\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p3 = 0.7048412273118333 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p30\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p30 = 0.657317018896963 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p31\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p31 = 1.3007873908228318 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p32\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p32 = 0.018812768340265774 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p33\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p33 = 5.375620443862485 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p34\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p34 = 1.3739383331654635 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p35\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p35 = 0.005465669647937541 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p36\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p36 = 0.08027321822083551 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p37\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p37 = 0.02910616047112839 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p38\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p38 = 0.04789383192254678 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p39\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p39 = 0.007885149088637952 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p4\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p4 = 3.5404334534944213 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p40\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p40 = 0.05625081723583953 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p41\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p41 = 30.227444009696498 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p42\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p42 = 0.06264291863132125 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p43\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p43 = 2.9994299985436417 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p44\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p44 = 0.24093939203319095 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p45\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p45 = 0.10717607601536447 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p46\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p46 = 0.19838532518278984 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p47\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p47 = 0.14738011463187053 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p48\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p48 = 0.0984018162656421 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p49\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p49 = 0.00567950006473322 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p5\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p5 = 3.1848034226229043 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p50\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p50 = 11.34742410893453 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p51\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p51 = 9.953582353842945 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p52\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p52 = 7.654663522774303 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p53\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p53 = 15.872990282554714 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p54\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p54 = 0.10398282436742064 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p55\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p55 = 0.20821109084549758 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p56\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p56 = 0.09154387246877732 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p57\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p57 = 0.037235300799680175 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p58\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p58 = 2.939310664704733 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p59\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p59 = 2.6515438778528053 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p6\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p6 = 3.6401960906161848 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p60\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p60 = 18.213350080512516 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p61\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p61 = 26.061591821673108 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p62\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p62 = 11.936568040014013 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p63\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p63 = 11.925600295047104 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p64\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p64 = 2.0781089987865324 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p65\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p65 = 0.6752061533801665 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p66\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p66 = 0.4193369901254439 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p67\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p67 = 31.270827272524684 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p68\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p68 = 0.19942855854639704 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p69\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p69 = 1.6842166328016495 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p7\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p7 = 1.6680748239592238 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p70\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p70 = 0.17276097574611388 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p71\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p71 = 0.00630722200044581 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p72\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p72 = 0.08640449735347053 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p73\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p73 = 0.24350746672054713 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p74\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p74 = 0.0036645469440469806 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p75\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p75 = 0.11193087444197448 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p76\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p76 = 2.896061426499621 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p77\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p77 = 6.39088596342345 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p78\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p78 = 0.12257025106399634 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p79\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p79 = 0.14278802600611834 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p8\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p8 = 0.5371983638559684 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p80\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p80 = 1.085264061445474 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p81\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p81 = 0.9965912495384177 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p82\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p82 = 24.855933812232255 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p83\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p83 = 27.035971470086306 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p84\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p84 = 0.017850624638343273 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p85\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p85 = 0.616284709614732 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p86\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p86 = 0.1114196134649388 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p87\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p87 = 6.8377150082929825 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p88\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p88 = 0.05904351658333102 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p89\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p89 = 1.1148120543260336 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p9\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p9 = 22.219204165103182 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p90\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p90 = 0.2272922265904582 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p91\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p91 = 38.61409260281129 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p92\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p92 = 18.60164567295098 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p93\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p93 = 10.789387694690653 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p94\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p94 = 12.154734960194567 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p95\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p95 = 57.466537349363435 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p96\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p96 = 29.48711100628829 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p97\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p97 = 4.17925266577436 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p98\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p98 = 9.823608336650043 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n", + "Working on Scenario: p99\n", + "********************\n", + "Finished Area+Power Generation Calculations\n", + "==> Working on Material : cadmium\n", + "==> Working on Material : tellurium\n", + "==> Working on Material : glass_cdte\n", + "==> Working on Material : aluminium_frames_cdte\n", + "Recycled surplus End of Sim for Mat aluminium_frames_cdte Scenario p99 = 16.35812444558685 tonnes.\n", + "==> Working on Material : encapsulant_cdte\n", + "==> Working on Material : copper_cdte\n" + ] + } + ], + "source": [ + "r2.calculateMassFlow()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "eec0c18f-333d-48e4-b8cf-822e833f9ce9", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PCAs: dict_keys(['p1', 'p10', 'p100', 'p101', 'p102', 'p103', 'p104', 'p105', 'p106', 'p107', 'p108', 'p109', 'p11', 'p110', 'p111', 'p112', 'p113', 'p114', 'p115', 'p116', 'p117', 'p118', 'p119', 'p12', 'p120', 'p121', 'p122', 'p123', 'p124', 'p125', 'p126', 'p127', 'p128', 'p129', 'p13', 'p130', 'p131', 'p132', 'p133', 'p134', 'p14', 'p15', 'p16', 'p17', 'p18', 'p19', 'p2', 'p20', 'p21', 'p22', 'p23', 'p24', 'p25', 'p26', 'p27', 'p28', 'p29', 'p3', 'p30', 'p31', 'p32', 'p33', 'p34', 'p35', 'p36', 'p37', 'p38', 'p39', 'p4', 'p40', 'p41', 'p42', 'p43', 'p44', 'p45', 'p46', 'p47', 'p48', 'p49', 'p5', 'p50', 'p51', 'p52', 'p53', 'p54', 'p55', 'p56', 'p57', 'p58', 'p59', 'p6', 'p60', 'p61', 'p62', 'p63', 'p64', 'p65', 'p66', 'p67', 'p68', 'p69', 'p7', 'p70', 'p71', 'p72', 'p73', 'p74', 'p75', 'p76', 'p77', 'p78', 'p79', 'p8', 'p80', 'p81', 'p82', 'p83', 'p84', 'p85', 'p86', 'p87', 'p88', 'p89', 'p9', 'p90', 'p91', 'p92', 'p93', 'p94', 'p95', 'p96', 'p97', 'p98', 'p99'])\n", + "Module Keys: Index(['year', 'new_Installed_Capacity_[MW]', 'mod_eff', 'mod_reliability_t50',\n", + " 'mod_reliability_t90', 'mod_degradation', 'mod_lifetime', 'mod_MFG_eff',\n", + " 'mod_Repair', 'mod_MerchantTail', 'mod_EOL_collection_eff',\n", + " 'mod_EOL_pg0_resell', 'mod_EOL_pg1_landfill', 'mod_EOL_pg2_stored',\n", + " 'mod_EOL_pg3_reMFG', 'mod_EOL_pg4_recycled', 'mod_EOL_reMFG_yield',\n", + " 'mod_EOL_sp_reMFG_recycle', 'mod_EOL_pb1_landfill',\n", + " 'mod_EOL_pb2_stored', 'mod_EOL_pb3_reMFG', 'mod_EOL_pb4_recycled'],\n", + " dtype='object')\n", + "Material Keys: Index(['year', 'mat_virgin_eff', 'mat_massperm2', 'mat_MFG_eff',\n", + " 'mat_MFG_scrap_Recycled', 'mat_MFG_scrap_Recycling_eff',\n", + " 'mat_MFG_scrap_Recycled_into_HQ',\n", + " 'mat_MFG_scrap_Recycled_into_HQ_Reused4MFG', 'mat_PG3_ReMFG_target',\n", + " 'mat_ReMFG_yield', 'mat_PG4_Recycling_target', 'mat_Recycling_yield',\n", + " 'mat_EOL_Recycled_into_HQ', 'mat_EOL_RecycledHQ_Reused4MFG'],\n", + " dtype='object')\n" + ] + } + ], + "source": [ + "print(\"PCAs:\", r1.scenario.keys())\n", + "print(\"Module Keys:\", r1.scenario[PCAs[jj]].dataIn_m.keys())\n", + "print(\"Material Keys: \", r1.scenario[PCAs[jj]].material['glass'].matdataIn_m.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "309a55ed-59ec-45fe-9e84-995d95454915", + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "r1.plotScenariosComparison(keyword='Cumulative_Area_disposedby_Failure')\n", + "r1.plotMaterialComparisonAcrossScenarios(material='silicon', keyword='mat_Total_Landfilled')\n", + "r1.scenario['p1'].dataIn_m.head(21)\n", + "r2.scenario['p1'].dataIn_m.head(21)\n", + "r3.scenario['p1'].dataIn_m.head(21)\n", + "\"\"\"\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "id": "78a33661-77fe-4ad9-95da-af56c93e0ced", + "metadata": {}, + "source": [ + "## 4. Aggregate & Save Data" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "cbc7f272-2b87-4fe1-8a3d-8f0919e57481", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2164: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_'+mat+'_'+self.name+'_'+scen] = self.scenario[scen].material[mat].matdataOut_m[keywd]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2166: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly[nicekey+'_Module_'+self.name+'_'+scen] = USyearly[filter_col].sum(axis=1)\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2177: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataIn_m[keywd1]\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2188: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'] = self.scenario[scen].dataOut_m[keywd]/1e6 #this value is cumulative\n", + "C:\\Users\\sayala\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2190: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " USyearly['DecommisionedCapacity_'+self.name+'_'+scen+'_[MW]'] = (UScum['newInstalledCapacity_'+self.name+'_'+scen+'_[MW]'] - USyearly['ActiveCapacity_'+self.name+'_'+scen+'_[MW]'])\n" + ] + }, + { + "data": { + "text/plain": [ + "( VirginStock_cadmium_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000144 \n", + " 2011 0.014917 \n", + " 2012 0.018509 \n", + " 2013 0.041144 \n", + " 2014 0.106725 \n", + " 2015 0.057494 \n", + " 2016 0.091543 \n", + " 2017 0.071567 \n", + " 2018 0.082375 \n", + " 2019 0.202774 \n", + " 2020 0.206662 \n", + " 2021 0.013338 \n", + " 2022 0.013211 \n", + " 2023 0.052675 \n", + " 2024 0.051916 \n", + " 2025 4.576990 \n", + " 2026 4.531359 \n", + " 2027 0.233483 \n", + " 2028 0.231702 \n", + " 2029 0.474799 \n", + " 2030 0.471867 \n", + " 2031 0.378692 \n", + " 2032 0.376727 \n", + " 2033 1.587109 \n", + " 2034 1.580008 \n", + " 2035 0.197020 \n", + " 2036 0.196245 \n", + " 2037 0.160922 \n", + " 2038 0.160357 \n", + " 2039 0.183346 \n", + " 2040 0.182766 \n", + " 2041 0.200921 \n", + " 2042 0.200341 \n", + " 2043 0.185207 \n", + " 2044 0.184716 \n", + " 2045 0.070062 \n", + " 2046 0.069891 \n", + " 2047 0.236806 \n", + " 2048 0.236267 \n", + " 2049 0.297071 \n", + " 2050 0.296438 \n", + " \n", + " VirginStock_tellurium_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000164 \n", + " 2011 0.016932 \n", + " 2012 0.021010 \n", + " 2013 0.046703 \n", + " 2014 0.121146 \n", + " 2015 0.065262 \n", + " 2016 0.103912 \n", + " 2017 0.081237 \n", + " 2018 0.093505 \n", + " 2019 0.230173 \n", + " 2020 0.234586 \n", + " 2021 0.015140 \n", + " 2022 0.014996 \n", + " 2023 0.059792 \n", + " 2024 0.080361 \n", + " 2025 7.793151 \n", + " 2026 5.143637 \n", + " 2027 0.265031 \n", + " 2028 0.263010 \n", + " 2029 0.538954 \n", + " 2030 0.535626 \n", + " 2031 0.429861 \n", + " 2032 0.427630 \n", + " 2033 1.801560 \n", + " 2034 1.793499 \n", + " 2035 0.223641 \n", + " 2036 0.222761 \n", + " 2037 0.182666 \n", + " 2038 0.182025 \n", + " 2039 0.208120 \n", + " 2040 0.207461 \n", + " 2041 0.228069 \n", + " 2042 0.227411 \n", + " 2043 0.210232 \n", + " 2044 0.209675 \n", + " 2045 0.079529 \n", + " 2046 0.079334 \n", + " 2047 0.268804 \n", + " 2048 0.268191 \n", + " 2049 0.337211 \n", + " 2050 0.336493 \n", + " \n", + " VirginStock_glass_cdte_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.280724 \n", + " 2011 39.594760 \n", + " 2012 49.129197 \n", + " 2013 109.211630 \n", + " 2014 282.359782 \n", + " 2015 151.609294 \n", + " 2016 240.597406 \n", + " 2017 187.471706 \n", + " 2018 215.305597 \n", + " 2019 526.466947 \n", + " 2020 530.560642 \n", + " 2021 33.002780 \n", + " 2022 32.459784 \n", + " 2023 127.890665 \n", + " 2024 124.541722 \n", + " 2025 11946.161595 \n", + " 2026 11696.820598 \n", + " 2027 599.209622 \n", + " 2028 591.185935 \n", + " 2029 1204.371753 \n", + " 2030 1188.895367 \n", + " 2031 947.683265 \n", + " 2032 936.346652 \n", + " 2033 3944.748393 \n", + " 2034 3927.076785 \n", + " 2035 489.654114 \n", + " 2036 487.746719 \n", + " 2037 399.888752 \n", + " 2038 398.538241 \n", + " 2039 455.668863 \n", + " 2040 454.092671 \n", + " 2041 499.339811 \n", + " 2042 497.885189 \n", + " 2043 460.204007 \n", + " 2044 458.944741 \n", + " 2045 174.041990 \n", + " 2046 173.537978 \n", + " 2047 588.433488 \n", + " 2048 587.005742 \n", + " 2049 738.028584 \n", + " 2050 736.274597 \n", + " \n", + " VirginStock_aluminium_frames_cdte_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.000000 \n", + " 2014 0.000000 \n", + " 2015 0.000000 \n", + " 2016 0.000000 \n", + " 2017 0.000000 \n", + " 2018 1.606185 \n", + " 2019 6.797993 \n", + " 2020 13.911282 \n", + " 2021 1.795646 \n", + " 2022 1.778625 \n", + " 2023 7.091521 \n", + " 2024 10.484108 \n", + " 2025 1355.623882 \n", + " 2026 1342.108629 \n", + " 2027 51.865102 \n", + " 2028 34.313011 \n", + " 2029 70.313566 \n", + " 2030 69.879261 \n", + " 2031 28.040292 \n", + " 2032 13.892376 \n", + " 2033 34.040369 \n", + " 2034 23.397437 \n", + " 2035 2.915742 \n", + " 2036 2.902782 \n", + " 2037 2.377163 \n", + " 2038 2.364642 \n", + " 2039 0.000000 \n", + " 2040 0.000000 \n", + " 2041 0.000000 \n", + " 2042 0.000000 \n", + " 2043 0.000000 \n", + " 2044 0.000000 \n", + " 2045 0.000000 \n", + " 2046 0.000000 \n", + " 2047 0.000000 \n", + " 2048 0.000000 \n", + " 2049 0.000000 \n", + " 2050 0.000000 \n", + " \n", + " VirginStock_encapsulant_cdte_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.006809 \n", + " 2011 0.960420 \n", + " 2012 1.191690 \n", + " 2013 2.649065 \n", + " 2014 6.871537 \n", + " 2015 3.701766 \n", + " 2016 5.894010 \n", + " 2017 4.607838 \n", + " 2018 5.303720 \n", + " 2019 13.055708 \n", + " 2020 13.306016 \n", + " 2021 0.858759 \n", + " 2022 0.850619 \n", + " 2023 3.391488 \n", + " 2024 3.342652 \n", + " 2025 324.160495 \n", + " 2026 320.928692 \n", + " 2027 16.536171 \n", + " 2028 16.410055 \n", + " 2029 33.627170 \n", + " 2030 33.419488 \n", + " 2031 26.820462 \n", + " 2032 26.681284 \n", + " 2033 112.405348 \n", + " 2034 111.902390 \n", + " 2035 13.953699 \n", + " 2036 13.898821 \n", + " 2037 11.397117 \n", + " 2038 11.357134 \n", + " 2039 12.985322 \n", + " 2040 12.944206 \n", + " 2041 14.229988 \n", + " 2042 14.188931 \n", + " 2043 13.117083 \n", + " 2044 13.082324 \n", + " 2045 4.962089 \n", + " 2046 4.949931 \n", + " 2047 16.771563 \n", + " 2048 16.733352 \n", + " 2049 21.039713 \n", + " 2050 20.994918 \n", + " \n", + " VirginStock_copper_cdte_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000992 \n", + " 2011 0.139943 \n", + " 2012 0.173641 \n", + " 2013 0.385995 \n", + " 2014 1.001251 \n", + " 2015 0.539384 \n", + " 2016 0.858815 \n", + " 2017 0.671408 \n", + " 2018 0.772804 \n", + " 2019 1.902345 \n", + " 2020 1.938818 \n", + " 2021 0.125130 \n", + " 2022 0.123944 \n", + " 2023 0.494173 \n", + " 2024 0.487057 \n", + " 2025 47.233383 \n", + " 2026 46.762478 \n", + " 2027 2.409483 \n", + " 2028 2.391107 \n", + " 2029 4.899811 \n", + " 2030 4.869549 \n", + " 2031 3.908006 \n", + " 2032 3.887726 \n", + " 2033 16.378568 \n", + " 2034 16.305283 \n", + " 2035 2.033192 \n", + " 2036 2.025195 \n", + " 2037 1.660672 \n", + " 2038 1.654846 \n", + " 2039 1.892090 \n", + " 2040 1.886099 \n", + " 2041 2.073450 \n", + " 2042 2.067467 \n", + " 2043 1.911288 \n", + " 2044 1.906224 \n", + " 2045 0.723025 \n", + " 2046 0.721254 \n", + " 2047 2.443782 \n", + " 2048 2.438215 \n", + " 2049 3.065694 \n", + " 2050 3.059167 \n", + " \n", + " VirginStock_Module_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.288834 \n", + " 2011 40.726972 \n", + " 2012 50.534047 \n", + " 2013 112.334536 \n", + " 2014 290.460441 \n", + " 2015 155.973200 \n", + " 2016 247.545686 \n", + " 2017 192.903755 \n", + " 2018 223.164186 \n", + " 2019 548.655941 \n", + " 2020 560.158006 \n", + " 2021 35.810792 \n", + " 2022 35.241180 \n", + " 2023 138.980314 \n", + " 2024 138.987816 \n", + " 2025 13685.549496 \n", + " 2026 13416.295393 \n", + " 2027 670.518892 \n", + " 2028 644.794821 \n", + " 2029 1314.226053 \n", + " 2030 1298.071158 \n", + " 2031 1007.260579 \n", + " 2032 981.612396 \n", + " 2033 4110.961348 \n", + " 2034 4082.055402 \n", + " 2035 508.977407 \n", + " 2036 506.992524 \n", + " 2037 415.667291 \n", + " 2038 414.257245 \n", + " 2039 470.937741 \n", + " 2040 469.313203 \n", + " 2041 516.072238 \n", + " 2042 514.569340 \n", + " 2043 475.627817 \n", + " 2044 474.327679 \n", + " 2045 179.876696 \n", + " 2046 179.358388 \n", + " 2047 608.154444 \n", + " 2048 606.681767 \n", + " 2049 762.768272 \n", + " 2050 760.961613 \n", + " \n", + " WasteAll_cadmium_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000000e+00 \n", + " 2011 6.233442e-14 \n", + " 2012 1.236841e-11 \n", + " 2013 7.008299e-10 \n", + " 2014 9.565245e-09 \n", + " 2015 6.283079e-08 \n", + " 2016 2.697231e-07 \n", + " 2017 8.833519e-07 \n", + " 2018 2.410029e-06 \n", + " 2019 5.774107e-06 \n", + " 2020 1.255816e-05 \n", + " 2021 2.534003e-05 \n", + " 2022 4.815156e-05 \n", + " 2023 8.708635e-05 \n", + " 2024 1.510703e-04 \n", + " 2025 2.527893e-04 \n", + " 2026 4.097461e-04 \n", + " 2027 6.453917e-04 \n", + " 2028 9.902422e-04 \n", + " 2029 1.482858e-03 \n", + " 2030 2.170554e-03 \n", + " 2031 3.109693e-03 \n", + " 2032 4.472399e-03 \n", + " 2033 6.000393e-03 \n", + " 2034 1.810907e-02 \n", + " 2035 2.196678e-02 \n", + " 2036 1.124847e-02 \n", + " 2037 4.794089e-02 \n", + " 2038 1.737626e-02 \n", + " 2039 2.274362e-02 \n", + " 2040 1.005536e-01 \n", + " 2041 2.840011e-02 \n", + " 2042 3.657291e-02 \n", + " 2043 7.514245e-02 \n", + " 2044 9.853986e-02 \n", + " 2045 5.811215e-02 \n", + " 2046 1.038482e-01 \n", + " 2047 8.839511e-02 \n", + " 2048 1.398340e-01 \n", + " 2049 2.023992e-01 \n", + " 2050 3.123124e-01 \n", + " \n", + " WasteAll_tellurium_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000000e+00 \n", + " 2011 7.075710e-14 \n", + " 2012 1.403963e-11 \n", + " 2013 7.955262e-10 \n", + " 2014 1.085770e-08 \n", + " 2015 7.132050e-08 \n", + " 2016 3.061681e-07 \n", + " 2017 1.002711e-06 \n", + " 2018 2.735673e-06 \n", + " 2019 6.554305e-06 \n", + " 2020 1.425502e-05 \n", + " 2021 2.876398e-05 \n", + " 2022 5.465781e-05 \n", + " 2023 9.885348e-05 \n", + " 2024 1.714830e-04 \n", + " 2025 2.869463e-04 \n", + " 2026 4.651111e-04 \n", + " 2027 7.325973e-04 \n", + " 2028 1.124047e-03 \n", + " 2029 1.683250e-03 \n", + " 2030 2.464008e-03 \n", + " 2031 3.530606e-03 \n", + " 2032 5.079215e-03 \n", + " 2033 6.818398e-03 \n", + " 2034 2.057430e-02 \n", + " 2035 2.497690e-02 \n", + " 2036 1.285688e-02 \n", + " 2037 5.459325e-02 \n", + " 2038 2.004965e-02 \n", + " 2039 2.639541e-02 \n", + " 2040 1.151279e-01 \n", + " 2041 3.386347e-02 \n", + " 2042 4.410927e-02 \n", + " 2043 8.932229e-02 \n", + " 2044 1.179487e-01 \n", + " 2045 7.497965e-02 \n", + " 2046 1.309397e-01 \n", + " 2047 1.188883e-01 \n", + " 2048 1.845859e-01 \n", + " 2049 2.651424e-01 \n", + " 2050 4.020940e-01 \n", + " \n", + " WasteAll_glass_cdte_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] ... \\\n", + " year ... \n", + " 2010 0.000000e+00 ... \n", + " 2011 1.147848e-10 ... \n", + " 2012 2.709290e-08 ... \n", + " 2013 1.705976e-06 ... \n", + " 2014 2.369206e-05 ... \n", + " 2015 1.564841e-04 ... \n", + " 2016 6.734038e-04 ... \n", + " 2017 2.208320e-03 ... \n", + " 2018 6.029697e-03 ... \n", + " 2019 1.445364e-02 ... \n", + " 2020 3.144530e-02 ... \n", + " 2021 6.346211e-02 ... \n", + " 2022 1.206002e-01 ... \n", + " 2023 2.181111e-01 ... \n", + " 2024 3.783225e-01 ... \n", + " 2025 6.329469e-01 ... \n", + " 2026 1.025710e+00 ... \n", + " 2027 1.615157e+00 ... \n", + " 2028 2.477418e+00 ... \n", + " 2029 3.708617e+00 ... \n", + " 2030 5.426592e+00 ... \n", + " 2031 7.771562e+00 ... \n", + " 2032 1.110234e+01 ... \n", + " 2033 1.498987e+01 ... \n", + " 2034 4.535685e+01 ... \n", + " 2035 5.498947e+01 ... \n", + " 2036 2.799999e+01 ... \n", + " 2037 1.200334e+02 ... \n", + " 2038 4.314543e+01 ... \n", + " 2039 5.643879e+01 ... \n", + " 2040 2.509945e+02 ... \n", + " 2041 7.016032e+01 ... \n", + " 2042 9.029259e+01 ... \n", + " 2043 1.861736e+02 ... \n", + " 2044 2.437335e+02 ... \n", + " 2045 1.427835e+02 ... \n", + " 2046 2.557046e+02 ... \n", + " 2047 2.168788e+02 ... \n", + " 2048 3.435355e+02 ... \n", + " 2049 4.965101e+02 ... \n", + " 2050 7.621334e+02 ... \n", + " \n", + " ActiveCapacity_95-by-35_Elec.Adv_DR_CdTe_p95_[MW] \\\n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.040576 \n", + " 2014 0.147498 \n", + " 2015 0.940702 \n", + " 2016 2.235558 \n", + " 2017 5.554908 \n", + " 2018 9.505049 \n", + " 2019 19.943241 \n", + " 2020 30.950926 \n", + " 2021 38.761481 \n", + " 2022 46.513431 \n", + " 2023 1111.711421 \n", + " 2024 2170.518495 \n", + " 2025 3781.914180 \n", + " 2026 5383.641232 \n", + " 2027 5992.729152 \n", + " 2028 6598.160670 \n", + " 2029 7100.296922 \n", + " 2030 7599.413807 \n", + " 2031 7865.144370 \n", + " 2032 8129.567932 \n", + " 2033 8427.226667 \n", + " 2034 8723.375487 \n", + " 2035 8894.129679 \n", + " 2036 9063.890719 \n", + " 2037 9442.848646 \n", + " 2038 9819.515227 \n", + " 2039 9897.971129 \n", + " 2040 9974.926116 \n", + " 2041 9921.886295 \n", + " 2042 9866.824157 \n", + " 2043 10037.563190 \n", + " 2044 10202.751842 \n", + " 2045 11596.305989 \n", + " 2046 12973.405805 \n", + " 2047 12873.460270 \n", + " 2048 12758.567933 \n", + " 2049 12622.617085 \n", + " 2050 12461.158237 \n", + " \n", + " DecommisionedCapacity_95-by-35_Elec.Adv_DR_CdTe_p95_[MW] \\\n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.000000 \n", + " 2014 0.000304 \n", + " 2015 0.001411 \n", + " 2016 0.008466 \n", + " 2017 0.025233 \n", + " 2018 0.066895 \n", + " 2019 0.138183 \n", + " 2020 0.287761 \n", + " 2021 0.519906 \n", + " 2022 0.810656 \n", + " 2023 1.147550 \n", + " 2024 7.875359 \n", + " 2025 20.955927 \n", + " 2026 43.705127 \n", + " 2027 76.065549 \n", + " 2028 112.082373 \n", + " 2029 151.735382 \n", + " 2030 194.407759 \n", + " 2031 239.544756 \n", + " 2032 285.988755 \n", + " 2033 333.749262 \n", + " 2034 383.019684 \n", + " 2035 433.837583 \n", + " 2036 485.648634 \n", + " 2037 538.588541 \n", + " 2038 593.819793 \n", + " 2039 651.615274 \n", + " 2040 710.911668 \n", + " 2041 772.096695 \n", + " 2042 835.304038 \n", + " 2043 901.817407 \n", + " 2044 973.881156 \n", + " 2045 1052.380398 \n", + " 2046 1147.333972 \n", + " 2047 1258.932777 \n", + " 2048 1385.478384 \n", + " 2049 1531.235892 \n", + " 2050 1702.501400 \n", + " \n", + " ActiveCapacity_95-by-35_Elec.Adv_DR_CdTe_p96_[MW] \\\n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.320559 \n", + " 2014 1.165258 \n", + " 2015 3.489615 \n", + " 2016 7.287493 \n", + " 2017 36.280118 \n", + " 2018 70.764302 \n", + " 2019 270.353751 \n", + " 2020 480.781237 \n", + " 2021 491.090913 \n", + " 2022 501.323122 \n", + " 2023 695.000096 \n", + " 2024 887.519371 \n", + " 2025 1290.641994 \n", + " 2026 1691.345529 \n", + " 2027 1881.941592 \n", + " 2028 2071.378278 \n", + " 2029 2212.838198 \n", + " 2030 2353.393379 \n", + " 2031 2900.110540 \n", + " 2032 3443.963321 \n", + " 2033 3610.923456 \n", + " 2034 3776.743258 \n", + " 2035 5563.263265 \n", + " 2036 7340.233395 \n", + " 2037 7557.688873 \n", + " 2038 7773.163091 \n", + " 2039 7848.135672 \n", + " 2040 7920.404504 \n", + " 2041 9758.313179 \n", + " 2042 11584.226307 \n", + " 2043 11615.183398 \n", + " 2044 11641.757882 \n", + " 2045 11744.712487 \n", + " 2046 11833.060699 \n", + " 2047 11759.518713 \n", + " 2048 11672.484656 \n", + " 2049 11575.229478 \n", + " 2050 11412.380117 \n", + " \n", + " DecommisionedCapacity_95-by-35_Elec.Adv_DR_CdTe_p96_[MW] \\\n", + " year \n", + " 2010 0.000000e+00 \n", + " 2011 0.000000e+00 \n", + " 2012 0.000000e+00 \n", + " 2013 5.551115e-17 \n", + " 2014 2.404191e-03 \n", + " 2015 1.114363e-02 \n", + " 2016 3.731576e-02 \n", + " 2017 9.197214e-02 \n", + " 2018 3.640741e-01 \n", + " 2019 8.948111e-01 \n", + " 2020 2.922483e+00 \n", + " 2021 6.528406e+00 \n", + " 2022 1.021180e+01 \n", + " 2023 1.395148e+01 \n", + " 2024 1.884886e+01 \n", + " 2025 2.489858e+01 \n", + " 2026 3.336739e+01 \n", + " 2027 4.424647e+01 \n", + " 2028 5.628494e+01 \n", + " 2029 6.949159e+01 \n", + " 2030 8.360298e+01 \n", + " 2031 9.849540e+01 \n", + " 2032 1.162522e+02 \n", + " 2033 1.369328e+02 \n", + " 2034 1.587538e+02 \n", + " 2035 1.818444e+02 \n", + " 2036 2.144850e+02 \n", + " 2037 2.570670e+02 \n", + " 2038 3.016304e+02 \n", + " 2039 3.487336e+02 \n", + " 2040 3.985406e+02 \n", + " 2041 4.505049e+02 \n", + " 2042 5.144647e+02 \n", + " 2043 5.918124e+02 \n", + " 2044 6.735427e+02 \n", + " 2045 7.577943e+02 \n", + " 2046 8.566522e+02 \n", + " 2047 9.490692e+02 \n", + " 2048 1.054978e+03 \n", + " 2049 1.205208e+03 \n", + " 2050 1.421031e+03 \n", + " \n", + " ActiveCapacity_95-by-35_Elec.Adv_DR_CdTe_p97_[MW] \\\n", + " year \n", + " 2010 1.465719 \n", + " 2011 3.716159 \n", + " 2012 6.550022 \n", + " 2013 15.997310 \n", + " 2014 40.972403 \n", + " 2015 59.389990 \n", + " 2016 89.635448 \n", + " 2017 111.938833 \n", + " 2018 138.590277 \n", + " 2019 171.359677 \n", + " 2020 205.965728 \n", + " 2021 214.230741 \n", + " 2022 222.428721 \n", + " 2023 231.986352 \n", + " 2024 241.475138 \n", + " 2025 258.250232 \n", + " 2026 274.893124 \n", + " 2027 1106.556882 \n", + " 2028 1933.158659 \n", + " 2029 2023.057328 \n", + " 2030 2112.271165 \n", + " 2031 3736.577052 \n", + " 2032 5351.587233 \n", + " 2033 6031.572143 \n", + " 2034 6706.463027 \n", + " 2035 7705.423908 \n", + " 2036 8700.552431 \n", + " 2037 9083.796009 \n", + " 2038 9471.008211 \n", + " 2039 9457.842336 \n", + " 2040 9429.815877 \n", + " 2041 9431.628913 \n", + " 2042 9432.302092 \n", + " 2043 9419.518039 \n", + " 2044 9402.277016 \n", + " 2045 9780.630929 \n", + " 2046 10148.770498 \n", + " 2047 10157.412145 \n", + " 2048 10158.463428 \n", + " 2049 10125.721272 \n", + " 2050 10082.305796 \n", + " \n", + " DecommisionedCapacity_95-by-35_Elec.Adv_DR_CdTe_p97_[MW] \\\n", + " year \n", + " 2010 2.220446e-16 \n", + " 2011 1.099289e-02 \n", + " 2012 3.886414e-02 \n", + " 2013 8.799020e-02 \n", + " 2014 2.079762e-01 \n", + " 2015 5.152970e-01 \n", + " 2016 9.608172e-01 \n", + " 2017 1.633352e+00 \n", + " 2018 2.473558e+00 \n", + " 2019 3.514463e+00 \n", + " 2020 4.802712e+00 \n", + " 2021 6.353384e+00 \n", + " 2022 7.971088e+00 \n", + " 2023 9.644073e+00 \n", + " 2024 1.138590e+01 \n", + " 2025 1.320430e+01 \n", + " 2026 1.515491e+01 \n", + " 2027 1.725387e+01 \n", + " 2028 2.441482e+01 \n", + " 2029 3.663909e+01 \n", + " 2030 4.954819e+01 \n", + " 2031 6.308942e+01 \n", + " 2032 8.592636e+01 \n", + " 2033 1.161607e+02 \n", + " 2034 1.514891e+02 \n", + " 2035 1.909068e+02 \n", + " 2036 2.341569e+02 \n", + " 2037 2.894915e+02 \n", + " 2038 3.408575e+02 \n", + " 2039 3.951663e+02 \n", + " 2040 4.643358e+02 \n", + " 2041 5.191363e+02 \n", + " 2042 5.750768e+02 \n", + " 2043 6.397491e+02 \n", + " 2044 7.088785e+02 \n", + " 2045 7.641281e+02 \n", + " 2046 8.295920e+02 \n", + " 2047 8.883138e+02 \n", + " 2048 9.546260e+02 \n", + " 2049 1.021157e+03 \n", + " 2050 1.098361e+03 \n", + " \n", + " ActiveCapacity_95-by-35_Elec.Adv_DR_CdTe_p98_[MW] \\\n", + " year \n", + " 2010 0.396735 \n", + " 2011 5.165874 \n", + " 2012 11.166013 \n", + " 2013 59.892803 \n", + " 2014 188.429584 \n", + " 2015 267.931149 \n", + " 2016 398.544639 \n", + " 2017 485.999387 \n", + " 2018 590.573687 \n", + " 2019 676.644248 \n", + " 2020 767.644513 \n", + " 2021 768.572389 \n", + " 2022 769.480742 \n", + " 2023 776.932404 \n", + " 2024 784.307218 \n", + " 2025 800.788159 \n", + " 2026 817.067592 \n", + " 2027 850.834172 \n", + " 2028 884.143574 \n", + " 2029 935.253840 \n", + " 2030 985.512546 \n", + " 2031 1025.526040 \n", + " 2032 1064.056327 \n", + " 2033 1389.677589 \n", + " 2034 1709.186429 \n", + " 2035 2207.105159 \n", + " 2036 2703.551067 \n", + " 2037 3196.541182 \n", + " 2038 3718.125553 \n", + " 2039 3716.150619 \n", + " 2040 3638.716362 \n", + " 2041 3638.522529 \n", + " 2042 3634.205455 \n", + " 2043 3594.645386 \n", + " 2044 3536.808625 \n", + " 2045 3570.806837 \n", + " 2046 3572.890516 \n", + " 2047 3718.519529 \n", + " 2048 3835.063328 \n", + " 2049 3812.589629 \n", + " 2050 3762.298358 \n", + " \n", + " DecommisionedCapacity_95-by-35_Elec.Adv_DR_CdTe_p98_[MW] \\\n", + " year \n", + " 2010 5.551115e-17 \n", + " 2011 2.975511e-03 \n", + " 2012 4.171959e-02 \n", + " 2013 1.254651e-01 \n", + " 2014 5.746653e-01 \n", + " 2015 1.987911e+00 \n", + " 2016 3.997494e+00 \n", + " 2017 6.986904e+00 \n", + " 2018 1.063282e+01 \n", + " 2019 1.506445e+01 \n", + " 2020 2.014474e+01 \n", + " 2021 2.591399e+01 \n", + " 2022 3.170275e+01 \n", + " 2023 3.751148e+01 \n", + " 2024 4.339705e+01 \n", + " 2025 4.938693e+01 \n", + " 2026 5.557832e+01 \n", + " 2027 6.203265e+01 \n", + " 2028 6.894416e+01 \n", + " 2029 7.643379e+01 \n", + " 2030 8.477498e+01 \n", + " 2031 9.412263e+01 \n", + " 2032 1.049535e+02 \n", + " 2033 1.170831e+02 \n", + " 2034 1.353252e+02 \n", + " 2035 1.578310e+02 \n", + " 2036 1.818097e+02 \n", + " 2037 2.441851e+02 \n", + " 2038 2.779662e+02 \n", + " 2039 3.185067e+02 \n", + " 2040 4.345066e+02 \n", + " 2041 4.755059e+02 \n", + " 2042 5.206284e+02 \n", + " 2043 6.025345e+02 \n", + " 2044 7.027174e+02 \n", + " 2045 7.418076e+02 \n", + " 2046 8.128124e+02 \n", + " 2047 8.488672e+02 \n", + " 2048 9.140073e+02 \n", + " 2049 9.682073e+02 \n", + " 2050 1.050225e+03 \n", + " \n", + " ActiveCapacity_95-by-35_Elec.Adv_DR_CdTe_p99_[MW] \\\n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.547204 \n", + " 2014 1.989134 \n", + " 2015 4.061463 \n", + " 2016 7.452096 \n", + " 2017 27.103882 \n", + " 2018 50.481661 \n", + " 2019 197.160552 \n", + " 2020 351.803637 \n", + " 2021 385.095932 \n", + " 2022 418.138387 \n", + " 2023 438.032902 \n", + " 2024 457.811393 \n", + " 2025 576.925592 \n", + " 2026 695.324785 \n", + " 2027 1598.148851 \n", + " 2028 2495.543948 \n", + " 2029 3056.955920 \n", + " 2030 3614.957374 \n", + " 2031 3704.301796 \n", + " 2032 3793.110733 \n", + " 2033 4679.589448 \n", + " 2034 5561.419849 \n", + " 2035 5723.222017 \n", + " 2036 5883.777267 \n", + " 2037 6856.756856 \n", + " 2038 7824.476288 \n", + " 2039 7815.457702 \n", + " 2040 7804.415046 \n", + " 2041 7798.141216 \n", + " 2042 7790.048145 \n", + " 2043 7840.981877 \n", + " 2044 7888.899122 \n", + " 2045 8520.066345 \n", + " 2046 9139.012477 \n", + " 2047 9789.805889 \n", + " 2048 10428.942279 \n", + " 2049 10380.738523 \n", + " 2050 10286.271078 \n", + " \n", + " DecommisionedCapacity_95-by-35_Elec.Adv_DR_CdTe_p99_[MW] \n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.000000 \n", + " 2014 0.004104 \n", + " 2015 0.019023 \n", + " 2016 0.049484 \n", + " 2017 0.105375 \n", + " 2018 0.308655 \n", + " 2019 0.687275 \n", + " 2020 2.166004 \n", + " 2021 4.804610 \n", + " 2022 7.693054 \n", + " 2023 10.775809 \n", + " 2024 13.974588 \n", + " 2025 17.289944 \n", + " 2026 21.320306 \n", + " 2027 26.065729 \n", + " 2028 36.240121 \n", + " 2029 51.822733 \n", + " 2030 70.815863 \n", + " 2031 92.649023 \n", + " 2032 115.017668 \n", + " 2033 137.973073 \n", + " 2034 165.576793 \n", + " 2035 197.902469 \n", + " 2036 231.475064 \n", + " 2037 266.810642 \n", + " 2038 307.406378 \n", + " 2039 353.853254 \n", + " 2040 402.324200 \n", + " 2041 451.410825 \n", + " 2042 502.316691 \n", + " 2043 556.163993 \n", + " 2044 613.027781 \n", + " 2045 671.029916 \n", + " 2046 741.253143 \n", + " 2047 809.183236 \n", + " 2048 888.770350 \n", + " 2049 1003.434396 \n", + " 2050 1164.362131 \n", + " \n", + " [41 rows x 4154 columns],\n", + " VirginStock_cadmium_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000144 \n", + " 2011 0.015061 \n", + " 2012 0.033570 \n", + " 2013 0.074714 \n", + " 2014 0.181439 \n", + " 2015 0.238932 \n", + " 2016 0.330475 \n", + " 2017 0.402042 \n", + " 2018 0.484416 \n", + " 2019 0.687191 \n", + " 2020 0.893852 \n", + " 2021 0.907190 \n", + " 2022 0.920402 \n", + " 2023 0.973076 \n", + " 2024 1.024993 \n", + " 2025 5.601983 \n", + " 2026 10.133341 \n", + " 2027 10.366824 \n", + " 2028 10.598526 \n", + " 2029 11.073326 \n", + " 2030 11.545193 \n", + " 2031 11.923885 \n", + " 2032 12.300612 \n", + " 2033 13.887721 \n", + " 2034 15.467729 \n", + " 2035 15.664748 \n", + " 2036 15.860993 \n", + " 2037 16.021915 \n", + " 2038 16.182272 \n", + " 2039 16.365619 \n", + " 2040 16.548385 \n", + " 2041 16.749305 \n", + " 2042 16.949646 \n", + " 2043 17.134853 \n", + " 2044 17.319569 \n", + " 2045 17.389631 \n", + " 2046 17.459522 \n", + " 2047 17.696328 \n", + " 2048 17.932595 \n", + " 2049 18.229666 \n", + " 2050 18.526104 \n", + " \n", + " VirginStock_tellurium_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000164 \n", + " 2011 0.017096 \n", + " 2012 0.038106 \n", + " 2013 0.084809 \n", + " 2014 0.205955 \n", + " 2015 0.271217 \n", + " 2016 0.375129 \n", + " 2017 0.456366 \n", + " 2018 0.549871 \n", + " 2019 0.780044 \n", + " 2020 1.014630 \n", + " 2021 1.029770 \n", + " 2022 1.044767 \n", + " 2023 1.104559 \n", + " 2024 1.184920 \n", + " 2025 8.978071 \n", + " 2026 14.121707 \n", + " 2027 14.386738 \n", + " 2028 14.649748 \n", + " 2029 15.188703 \n", + " 2030 15.724328 \n", + " 2031 16.154189 \n", + " 2032 16.581820 \n", + " 2033 18.383380 \n", + " 2034 20.176879 \n", + " 2035 20.400519 \n", + " 2036 20.623281 \n", + " 2037 20.805946 \n", + " 2038 20.987971 \n", + " 2039 21.196091 \n", + " 2040 21.403553 \n", + " 2041 21.631622 \n", + " 2042 21.859033 \n", + " 2043 22.069265 \n", + " 2044 22.278940 \n", + " 2045 22.358469 \n", + " 2046 22.437803 \n", + " 2047 22.706607 \n", + " 2048 22.974798 \n", + " 2049 23.312009 \n", + " 2050 23.648502 \n", + " \n", + " VirginStock_glass_cdte_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.280724 \n", + " 2011 39.875484 \n", + " 2012 89.004682 \n", + " 2013 198.216311 \n", + " 2014 480.576094 \n", + " 2015 632.185388 \n", + " 2016 872.782794 \n", + " 2017 1060.254500 \n", + " 2018 1275.560097 \n", + " 2019 1802.027044 \n", + " 2020 2332.587687 \n", + " 2021 2365.590466 \n", + " 2022 2398.050250 \n", + " 2023 2525.940915 \n", + " 2024 2650.482637 \n", + " 2025 14596.644232 \n", + " 2026 26293.464831 \n", + " 2027 26892.674453 \n", + " 2028 27483.860389 \n", + " 2029 28688.232141 \n", + " 2030 29877.127508 \n", + " 2031 30824.810773 \n", + " 2032 31761.157425 \n", + " 2033 35705.905819 \n", + " 2034 39632.982604 \n", + " 2035 40122.636718 \n", + " 2036 40610.383437 \n", + " 2037 41010.272189 \n", + " 2038 41408.810429 \n", + " 2039 41864.479292 \n", + " 2040 42318.571963 \n", + " 2041 42817.911773 \n", + " 2042 43315.796963 \n", + " 2043 43776.000970 \n", + " 2044 44234.945711 \n", + " 2045 44408.987701 \n", + " 2046 44582.525679 \n", + " 2047 45170.959167 \n", + " 2048 45757.964909 \n", + " 2049 46495.993493 \n", + " 2050 47232.268090 \n", + " \n", + " VirginStock_aluminium_frames_cdte_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.000000 \n", + " 2014 0.000000 \n", + " 2015 0.000000 \n", + " 2016 0.000000 \n", + " 2017 0.000000 \n", + " 2018 1.606185 \n", + " 2019 8.404178 \n", + " 2020 22.315460 \n", + " 2021 24.111106 \n", + " 2022 25.889731 \n", + " 2023 32.981252 \n", + " 2024 43.465360 \n", + " 2025 1399.089242 \n", + " 2026 2741.197871 \n", + " 2027 2793.062973 \n", + " 2028 2827.375985 \n", + " 2029 2897.689550 \n", + " 2030 2967.568811 \n", + " 2031 2995.609103 \n", + " 2032 3009.501479 \n", + " 2033 3043.541848 \n", + " 2034 3066.939285 \n", + " 2035 3069.855028 \n", + " 2036 3072.757810 \n", + " 2037 3075.134972 \n", + " 2038 3077.499614 \n", + " 2039 3077.499614 \n", + " 2040 3077.499614 \n", + " 2041 3077.499614 \n", + " 2042 3077.499614 \n", + " 2043 3077.499614 \n", + " 2044 3077.499614 \n", + " 2045 3077.499614 \n", + " 2046 3077.499614 \n", + " 2047 3077.499614 \n", + " 2048 3077.499614 \n", + " 2049 3077.499614 \n", + " 2050 3077.499614 \n", + " \n", + " VirginStock_encapsulant_cdte_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.006809 \n", + " 2011 0.967230 \n", + " 2012 2.158920 \n", + " 2013 4.807984 \n", + " 2014 11.679521 \n", + " 2015 15.381287 \n", + " 2016 21.275297 \n", + " 2017 25.883135 \n", + " 2018 31.186855 \n", + " 2019 44.242563 \n", + " 2020 57.548579 \n", + " 2021 58.407338 \n", + " 2022 59.257957 \n", + " 2023 62.649445 \n", + " 2024 65.992097 \n", + " 2025 390.152592 \n", + " 2026 711.081284 \n", + " 2027 727.617455 \n", + " 2028 744.027510 \n", + " 2029 777.654680 \n", + " 2030 811.074168 \n", + " 2031 837.894631 \n", + " 2032 864.575915 \n", + " 2033 976.981262 \n", + " 2034 1088.883653 \n", + " 2035 1102.837352 \n", + " 2036 1116.736173 \n", + " 2037 1128.133290 \n", + " 2038 1139.490424 \n", + " 2039 1152.475746 \n", + " 2040 1165.419953 \n", + " 2041 1179.649940 \n", + " 2042 1193.838872 \n", + " 2043 1206.955955 \n", + " 2044 1220.038278 \n", + " 2045 1225.000367 \n", + " 2046 1229.950299 \n", + " 2047 1246.721862 \n", + " 2048 1263.455214 \n", + " 2049 1284.494927 \n", + " 2050 1305.489845 \n", + " \n", + " VirginStock_copper_cdte_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000992 \n", + " 2011 0.140935 \n", + " 2012 0.314576 \n", + " 2013 0.700571 \n", + " 2014 1.701821 \n", + " 2015 2.241205 \n", + " 2016 3.100021 \n", + " 2017 3.771428 \n", + " 2018 4.544233 \n", + " 2019 6.446578 \n", + " 2020 8.385396 \n", + " 2021 8.510526 \n", + " 2022 8.634469 \n", + " 2023 9.128642 \n", + " 2024 9.615700 \n", + " 2025 56.849083 \n", + " 2026 103.611560 \n", + " 2027 106.021044 \n", + " 2028 108.412151 \n", + " 2029 113.311961 \n", + " 2030 118.181510 \n", + " 2031 122.089517 \n", + " 2032 125.977243 \n", + " 2033 142.355811 \n", + " 2034 158.661094 \n", + " 2035 160.694286 \n", + " 2036 162.719481 \n", + " 2037 164.380153 \n", + " 2038 166.035000 \n", + " 2039 167.927090 \n", + " 2040 169.813188 \n", + " 2041 171.886638 \n", + " 2042 173.954105 \n", + " 2043 175.865394 \n", + " 2044 177.771617 \n", + " 2045 178.494643 \n", + " 2046 179.215896 \n", + " 2047 181.659679 \n", + " 2048 184.097893 \n", + " 2049 187.163587 \n", + " 2050 190.222754 \n", + " \n", + " VirginStock_Module_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.288834 \n", + " 2011 41.015806 \n", + " 2012 91.549853 \n", + " 2013 203.884389 \n", + " 2014 494.344830 \n", + " 2015 650.318030 \n", + " 2016 897.863716 \n", + " 2017 1090.767471 \n", + " 2018 1313.931657 \n", + " 2019 1862.587598 \n", + " 2020 2422.745604 \n", + " 2021 2458.556396 \n", + " 2022 2493.797576 \n", + " 2023 2632.777890 \n", + " 2024 2771.765706 \n", + " 2025 16457.315203 \n", + " 2026 29873.610595 \n", + " 2027 30544.129488 \n", + " 2028 31188.924308 \n", + " 2029 32503.150361 \n", + " 2030 33801.221519 \n", + " 2031 34808.482098 \n", + " 2032 35790.094494 \n", + " 2033 39901.055841 \n", + " 2034 43983.111243 \n", + " 2035 44492.088651 \n", + " 2036 44999.081174 \n", + " 2037 45414.748466 \n", + " 2038 45829.005710 \n", + " 2039 46299.943452 \n", + " 2040 46769.256655 \n", + " 2041 47285.328893 \n", + " 2042 47799.898233 \n", + " 2043 48275.526050 \n", + " 2044 48749.853729 \n", + " 2045 48929.730425 \n", + " 2046 49109.088814 \n", + " 2047 49717.243258 \n", + " 2048 50323.925024 \n", + " 2049 51086.693296 \n", + " 2050 51847.654909 \n", + " \n", + " WasteAll_cadmium_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000000e+00 \n", + " 2011 6.233442e-14 \n", + " 2012 1.243074e-11 \n", + " 2013 7.132606e-10 \n", + " 2014 1.027851e-08 \n", + " 2015 7.310929e-08 \n", + " 2016 3.428323e-07 \n", + " 2017 1.226184e-06 \n", + " 2018 3.636214e-06 \n", + " 2019 9.410320e-06 \n", + " 2020 2.196848e-05 \n", + " 2021 4.730851e-05 \n", + " 2022 9.546007e-05 \n", + " 2023 1.825464e-04 \n", + " 2024 3.336168e-04 \n", + " 2025 5.864061e-04 \n", + " 2026 9.961522e-04 \n", + " 2027 1.641544e-03 \n", + " 2028 2.631786e-03 \n", + " 2029 4.114644e-03 \n", + " 2030 6.285198e-03 \n", + " 2031 9.394891e-03 \n", + " 2032 1.386729e-02 \n", + " 2033 1.986768e-02 \n", + " 2034 3.797675e-02 \n", + " 2035 5.994353e-02 \n", + " 2036 7.119201e-02 \n", + " 2037 1.191329e-01 \n", + " 2038 1.365092e-01 \n", + " 2039 1.592528e-01 \n", + " 2040 2.598064e-01 \n", + " 2041 2.882065e-01 \n", + " 2042 3.247794e-01 \n", + " 2043 3.999218e-01 \n", + " 2044 4.984617e-01 \n", + " 2045 5.565739e-01 \n", + " 2046 6.604221e-01 \n", + " 2047 7.488172e-01 \n", + " 2048 8.886512e-01 \n", + " 2049 1.091050e+00 \n", + " 2050 1.403363e+00 \n", + " \n", + " WasteAll_tellurium_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] \\\n", + " year \n", + " 2010 0.000000e+00 \n", + " 2011 7.075710e-14 \n", + " 2012 1.411039e-11 \n", + " 2013 8.096365e-10 \n", + " 2014 1.166734e-08 \n", + " 2015 8.298784e-08 \n", + " 2016 3.891559e-07 \n", + " 2017 1.391867e-06 \n", + " 2018 4.127540e-06 \n", + " 2019 1.068184e-05 \n", + " 2020 2.493687e-05 \n", + " 2021 5.370084e-05 \n", + " 2022 1.083587e-04 \n", + " 2023 2.072121e-04 \n", + " 2024 3.786951e-04 \n", + " 2025 6.656414e-04 \n", + " 2026 1.130752e-03 \n", + " 2027 1.863350e-03 \n", + " 2028 2.987396e-03 \n", + " 2029 4.670646e-03 \n", + " 2030 7.134654e-03 \n", + " 2031 1.066526e-02 \n", + " 2032 1.574448e-02 \n", + " 2033 2.256287e-02 \n", + " 2034 4.313718e-02 \n", + " 2035 6.811407e-02 \n", + " 2036 8.097095e-02 \n", + " 2037 1.355642e-01 \n", + " 2038 1.556139e-01 \n", + " 2039 1.820093e-01 \n", + " 2040 2.971371e-01 \n", + " 2041 3.310006e-01 \n", + " 2042 3.751099e-01 \n", + " 2043 4.644322e-01 \n", + " 2044 5.823809e-01 \n", + " 2045 6.573605e-01 \n", + " 2046 7.883002e-01 \n", + " 2047 9.071885e-01 \n", + " 2048 1.091774e+00 \n", + " 2049 1.356917e+00 \n", + " 2050 1.759011e+00 \n", + " \n", + " WasteAll_glass_cdte_95-by-35_Elec.Adv_DR_CdTe_p1_[Tonnes] ... \\\n", + " year ... \n", + " 2010 0.000000e+00 ... \n", + " 2011 1.147848e-10 ... \n", + " 2012 2.720769e-08 ... \n", + " 2013 1.733184e-06 ... \n", + " 2014 2.542524e-05 ... \n", + " 2015 1.819094e-04 ... \n", + " 2016 8.553132e-04 ... \n", + " 2017 3.063633e-03 ... \n", + " 2018 9.093330e-03 ... \n", + " 2019 2.354697e-02 ... \n", + " 2020 5.499227e-02 ... \n", + " 2021 1.184544e-01 ... \n", + " 2022 2.390546e-01 ... \n", + " 2023 4.571657e-01 ... \n", + " 2024 8.354882e-01 ... \n", + " 2025 1.468435e+00 ... \n", + " 2026 2.494145e+00 ... \n", + " 2027 4.109302e+00 ... \n", + " 2028 6.586720e+00 ... \n", + " 2029 1.029534e+01 ... \n", + " 2030 1.572193e+01 ... \n", + " 2031 2.349349e+01 ... \n", + " 2032 3.459583e+01 ... \n", + " 2033 4.958571e+01 ... \n", + " 2034 9.494256e+01 ... \n", + " 2035 1.499320e+02 ... \n", + " 2036 1.779320e+02 ... \n", + " 2037 2.979654e+02 ... \n", + " 2038 3.411109e+02 ... \n", + " 2039 3.975496e+02 ... \n", + " 2040 6.485442e+02 ... \n", + " 2041 7.187045e+02 ... \n", + " 2042 8.089971e+02 ... \n", + " 2043 9.951706e+02 ... \n", + " 2044 1.238904e+03 ... \n", + " 2045 1.381688e+03 ... \n", + " 2046 1.637392e+03 ... \n", + " 2047 1.854271e+03 ... \n", + " 2048 2.197806e+03 ... \n", + " 2049 2.694317e+03 ... \n", + " 2050 3.456450e+03 ... \n", + " \n", + " newInstalledCapacity_95-by-35_Elec.Adv_DR_CdTe_p90_[MW] \\\n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.072823 \n", + " 2014 0.265264 \n", + " 2015 0.306528 \n", + " 2016 0.374160 \n", + " 2017 7.635981 \n", + " 2018 16.325052 \n", + " 2019 16.455848 \n", + " 2020 16.594706 \n", + " 2021 16.923406 \n", + " 2022 17.252106 \n", + " 2023 18.210276 \n", + " 2024 19.168446 \n", + " 2025 21.747126 \n", + " 2026 24.325806 \n", + " 2027 30.017731 \n", + " 2028 35.709656 \n", + " 2029 46.190014 \n", + " 2030 56.670372 \n", + " 2031 108.059972 \n", + " 2032 159.449571 \n", + " 2033 165.779516 \n", + " 2034 172.109461 \n", + " 2035 604.772944 \n", + " 2036 1037.436427 \n", + " 2037 2152.323948 \n", + " 2038 3267.211469 \n", + " 2039 3272.107389 \n", + " 2040 3277.003309 \n", + " 2041 4701.113208 \n", + " 2042 6125.223107 \n", + " 2043 6309.542021 \n", + " 2044 6493.860935 \n", + " 2045 6509.058466 \n", + " 2046 6524.255996 \n", + " 2047 6540.327830 \n", + " 2048 6556.399664 \n", + " 2049 6576.681594 \n", + " 2050 6596.963524 \n", + " \n", + " newInstalledCapacity_95-by-35_Elec.Adv_DR_CdTe_p91_[MW] \\\n", + " year \n", + " 2010 0.065844 \n", + " 2011 0.142564 \n", + " 2012 0.239650 \n", + " 2013 0.413187 \n", + " 2014 0.871775 \n", + " 2015 1.079291 \n", + " 2016 1.419420 \n", + " 2017 10.617499 \n", + " 2018 21.623385 \n", + " 2019 23.648724 \n", + " 2020 25.798901 \n", + " 2021 29.128746 \n", + " 2022 32.458591 \n", + " 2023 37.387761 \n", + " 2024 42.316931 \n", + " 2025 1988.180901 \n", + " 2026 3934.044871 \n", + " 2027 3946.752641 \n", + " 2028 3959.460411 \n", + " 2029 3979.369751 \n", + " 2030 3999.279091 \n", + " 2031 4018.471656 \n", + " 2032 4037.664221 \n", + " 2033 4041.453486 \n", + " 2034 4045.242751 \n", + " 2035 4319.879201 \n", + " 2036 4594.515651 \n", + " 2037 4701.547108 \n", + " 2038 4808.578566 \n", + " 2039 4814.568411 \n", + " 2040 4820.558256 \n", + " 2041 4825.817455 \n", + " 2042 4831.076655 \n", + " 2043 4845.572363 \n", + " 2044 4860.068072 \n", + " 2045 4866.466132 \n", + " 2046 4872.864191 \n", + " 2047 4879.903976 \n", + " 2048 4886.943762 \n", + " 2049 4893.711561 \n", + " 2050 4900.479361 \n", + " \n", + " newInstalledCapacity_95-by-35_Elec.Adv_DR_CdTe_p92_[MW] \\\n", + " year \n", + " 2010 0.017447 \n", + " 2011 1.865721 \n", + " 2012 4.204624 \n", + " 2013 8.925054 \n", + " 2014 21.399191 \n", + " 2015 23.577982 \n", + " 2016 27.149120 \n", + " 2017 35.004901 \n", + " 2018 44.404672 \n", + " 2019 47.243863 \n", + " 2020 50.258056 \n", + " 2021 52.168506 \n", + " 2022 54.078956 \n", + " 2023 590.933555 \n", + " 2024 1127.788153 \n", + " 2025 1427.313137 \n", + " 2026 1726.838120 \n", + " 2027 1738.147870 \n", + " 2028 1749.457620 \n", + " 2029 1768.287380 \n", + " 2030 1787.117140 \n", + " 2031 1805.242760 \n", + " 2032 1823.368380 \n", + " 2033 1840.808100 \n", + " 2034 1858.247820 \n", + " 2035 1929.753934 \n", + " 2036 2001.260048 \n", + " 2037 2019.450838 \n", + " 2038 2037.641628 \n", + " 2039 2057.183983 \n", + " 2040 2076.726338 \n", + " 2041 2847.030330 \n", + " 2042 3617.334321 \n", + " 2043 4025.890781 \n", + " 2044 4434.447241 \n", + " 2045 6848.254773 \n", + " 2046 9262.062306 \n", + " 2047 10541.953778 \n", + " 2048 11821.845250 \n", + " 2049 11856.709680 \n", + " 2050 11891.574110 \n", + " \n", + " newInstalledCapacity_95-by-35_Elec.Adv_DR_CdTe_p93_[MW] \\\n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.016509 \n", + " 2014 0.060134 \n", + " 2015 0.095090 \n", + " 2016 0.152385 \n", + " 2017 0.393155 \n", + " 2018 0.681247 \n", + " 2019 0.681247 \n", + " 2020 0.681247 \n", + " 2021 0.681247 \n", + " 2022 0.681247 \n", + " 2023 61.305535 \n", + " 2024 121.929823 \n", + " 2025 602.346854 \n", + " 2026 1082.763886 \n", + " 2027 1082.786971 \n", + " 2028 1082.810056 \n", + " 2029 1083.015636 \n", + " 2030 1083.221216 \n", + " 2031 1083.504411 \n", + " 2032 1083.787606 \n", + " 2033 1084.211780 \n", + " 2034 1084.635955 \n", + " 2035 1085.234550 \n", + " 2036 1085.833145 \n", + " 2037 2560.111589 \n", + " 2038 4034.390032 \n", + " 2039 4248.528634 \n", + " 2040 4462.667237 \n", + " 2041 4700.454581 \n", + " 2042 4938.241925 \n", + " 2043 5105.971869 \n", + " 2044 5273.701813 \n", + " 2045 5409.819560 \n", + " 2046 5545.937307 \n", + " 2047 5548.466872 \n", + " 2048 5550.996437 \n", + " 2049 5556.161207 \n", + " 2050 5561.325977 \n", + " \n", + " newInstalledCapacity_95-by-35_Elec.Adv_DR_CdTe_p94_[MW] \\\n", + " year \n", + " 2010 0.132447 \n", + " 2011 0.973797 \n", + " 2012 2.038484 \n", + " 2013 9.409428 \n", + " 2014 28.887773 \n", + " 2015 81.049412 \n", + " 2016 166.544720 \n", + " 2017 170.403307 \n", + " 2018 175.020266 \n", + " 2019 305.757872 \n", + " 2020 444.553858 \n", + " 2021 448.676858 \n", + " 2022 452.799858 \n", + " 2023 514.611845 \n", + " 2024 576.423833 \n", + " 2025 581.119873 \n", + " 2026 585.815913 \n", + " 2027 595.367751 \n", + " 2028 604.919589 \n", + " 2029 1794.188728 \n", + " 2030 2983.457867 \n", + " 2031 2994.627777 \n", + " 2032 3005.797687 \n", + " 2033 3767.057579 \n", + " 2034 4528.317471 \n", + " 2035 4544.543946 \n", + " 2036 4560.770421 \n", + " 2037 4579.980560 \n", + " 2038 4599.190700 \n", + " 2039 4621.821790 \n", + " 2040 4644.452880 \n", + " 2041 4670.832670 \n", + " 2042 4697.212460 \n", + " 2043 5655.805579 \n", + " 2044 6614.398697 \n", + " 2045 6658.599822 \n", + " 2046 6702.800947 \n", + " 2047 6854.801707 \n", + " 2048 7006.802467 \n", + " 2049 7059.348202 \n", + " 2050 7111.893937 \n", + " \n", + " newInstalledCapacity_95-by-35_Elec.Adv_DR_CdTe_p95_[MW] \\\n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.040576 \n", + " 2014 0.147802 \n", + " 2015 0.942113 \n", + " 2016 2.244024 \n", + " 2017 5.580140 \n", + " 2018 9.571943 \n", + " 2019 20.081424 \n", + " 2020 31.238687 \n", + " 2021 39.281387 \n", + " 2022 47.324087 \n", + " 2023 1112.858971 \n", + " 2024 2178.393855 \n", + " 2025 3802.870107 \n", + " 2026 5427.346359 \n", + " 2027 6068.794701 \n", + " 2028 6710.243043 \n", + " 2029 7252.032305 \n", + " 2030 7793.821566 \n", + " 2031 8104.689126 \n", + " 2032 8415.556686 \n", + " 2033 8760.975929 \n", + " 2034 9106.395171 \n", + " 2035 9327.967262 \n", + " 2036 9549.539353 \n", + " 2037 9981.437187 \n", + " 2038 10413.335020 \n", + " 2039 10549.586402 \n", + " 2040 10685.837785 \n", + " 2041 10693.982990 \n", + " 2042 10702.128195 \n", + " 2043 10939.380597 \n", + " 2044 11176.632998 \n", + " 2045 12648.686388 \n", + " 2046 14120.739777 \n", + " 2047 14132.393047 \n", + " 2048 14144.046317 \n", + " 2049 14153.852977 \n", + " 2050 14163.659637 \n", + " \n", + " newInstalledCapacity_95-by-35_Elec.Adv_DR_CdTe_p96_[MW] \\\n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.320559 \n", + " 2014 1.167663 \n", + " 2015 3.500758 \n", + " 2016 7.324809 \n", + " 2017 36.372090 \n", + " 2018 71.128376 \n", + " 2019 271.248562 \n", + " 2020 483.703720 \n", + " 2021 497.619320 \n", + " 2022 511.534920 \n", + " 2023 708.951577 \n", + " 2024 906.368234 \n", + " 2025 1315.540577 \n", + " 2026 1724.712920 \n", + " 2027 1926.188067 \n", + " 2028 2127.663213 \n", + " 2029 2282.329787 \n", + " 2030 2436.996360 \n", + " 2031 2998.605944 \n", + " 2032 3560.215528 \n", + " 2033 3747.856274 \n", + " 2034 3935.497021 \n", + " 2035 5745.107699 \n", + " 2036 7554.718377 \n", + " 2037 7814.755917 \n", + " 2038 8074.793456 \n", + " 2039 8196.869261 \n", + " 2040 8318.945066 \n", + " 2041 10208.818061 \n", + " 2042 12098.691057 \n", + " 2043 12206.995812 \n", + " 2044 12315.300566 \n", + " 2045 12502.506740 \n", + " 2046 12689.712913 \n", + " 2047 12708.587893 \n", + " 2048 12727.462873 \n", + " 2049 12780.437153 \n", + " 2050 12833.411433 \n", + " \n", + " newInstalledCapacity_95-by-35_Elec.Adv_DR_CdTe_p97_[MW] \\\n", + " year \n", + " 2010 1.465719 \n", + " 2011 3.727151 \n", + " 2012 6.588886 \n", + " 2013 16.085300 \n", + " 2014 41.180379 \n", + " 2015 59.905287 \n", + " 2016 90.596265 \n", + " 2017 113.572185 \n", + " 2018 141.063834 \n", + " 2019 174.874140 \n", + " 2020 210.768440 \n", + " 2021 220.584125 \n", + " 2022 230.399810 \n", + " 2023 241.630425 \n", + " 2024 252.861040 \n", + " 2025 271.454535 \n", + " 2026 290.048030 \n", + " 2027 1123.810755 \n", + " 2028 1957.573481 \n", + " 2029 2059.696418 \n", + " 2030 2161.819354 \n", + " 2031 3799.666475 \n", + " 2032 5437.513597 \n", + " 2033 6147.732855 \n", + " 2034 6857.952113 \n", + " 2035 7896.330743 \n", + " 2036 8934.709373 \n", + " 2037 9373.287520 \n", + " 2038 9811.865668 \n", + " 2039 9853.008648 \n", + " 2040 9894.151628 \n", + " 2041 9950.765251 \n", + " 2042 10007.378874 \n", + " 2043 10059.267175 \n", + " 2044 10111.155476 \n", + " 2045 10544.758997 \n", + " 2046 10978.362517 \n", + " 2047 11045.725972 \n", + " 2048 11113.089427 \n", + " 2049 11146.877982 \n", + " 2050 11180.666537 \n", + " \n", + " newInstalledCapacity_95-by-35_Elec.Adv_DR_CdTe_p98_[MW] \\\n", + " year \n", + " 2010 0.396735 \n", + " 2011 5.168850 \n", + " 2012 11.207733 \n", + " 2013 60.018268 \n", + " 2014 189.004249 \n", + " 2015 269.919061 \n", + " 2016 402.542133 \n", + " 2017 492.986291 \n", + " 2018 601.206505 \n", + " 2019 691.708701 \n", + " 2020 787.789255 \n", + " 2021 794.486375 \n", + " 2022 801.183495 \n", + " 2023 814.443880 \n", + " 2024 827.704265 \n", + " 2025 850.175090 \n", + " 2026 872.645915 \n", + " 2027 912.866825 \n", + " 2028 953.087735 \n", + " 2029 1011.687630 \n", + " 2030 1070.287525 \n", + " 2031 1119.648670 \n", + " 2032 1169.009815 \n", + " 2033 1506.760709 \n", + " 2034 1844.511603 \n", + " 2035 2364.936180 \n", + " 2036 2885.360757 \n", + " 2037 3440.726242 \n", + " 2038 3996.091726 \n", + " 2039 4034.657356 \n", + " 2040 4073.222986 \n", + " 2041 4114.028431 \n", + " 2042 4154.833876 \n", + " 2043 4197.179936 \n", + " 2044 4239.525996 \n", + " 2045 4312.614436 \n", + " 2046 4385.702876 \n", + " 2047 4567.386766 \n", + " 2048 4749.070656 \n", + " 2049 4780.796951 \n", + " 2050 4812.523246 \n", + " \n", + " newInstalledCapacity_95-by-35_Elec.Adv_DR_CdTe_p99_[MW] \n", + " year \n", + " 2010 0.000000 \n", + " 2011 0.000000 \n", + " 2012 0.000000 \n", + " 2013 0.547204 \n", + " 2014 1.993238 \n", + " 2015 4.080485 \n", + " 2016 7.501579 \n", + " 2017 27.209256 \n", + " 2018 50.790316 \n", + " 2019 197.847827 \n", + " 2020 353.969641 \n", + " 2021 389.900541 \n", + " 2022 425.831441 \n", + " 2023 448.808711 \n", + " 2024 471.785981 \n", + " 2025 594.215536 \n", + " 2026 716.645090 \n", + " 2027 1624.214580 \n", + " 2028 2531.784069 \n", + " 2029 3108.778653 \n", + " 2030 3685.773237 \n", + " 2031 3796.950819 \n", + " 2032 3908.128400 \n", + " 2033 4817.562521 \n", + " 2034 5726.996641 \n", + " 2035 5921.124486 \n", + " 2036 6115.252331 \n", + " 2037 7123.567499 \n", + " 2038 8131.882666 \n", + " 2039 8169.310956 \n", + " 2040 8206.739246 \n", + " 2041 8249.552041 \n", + " 2042 8292.364836 \n", + " 2043 8397.145870 \n", + " 2044 8501.926903 \n", + " 2045 9191.096262 \n", + " 2046 9880.265620 \n", + " 2047 10598.989125 \n", + " 2048 11317.712629 \n", + " 2049 11384.172919 \n", + " 2050 11450.633209 \n", + " \n", + " [41 rows x 3886 columns])" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r1.aggregateResults()\n", + "r2.aggregateResults()" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "71e297d2-7b34-4513-a871-ee8186349fbf", + "metadata": {}, + "outputs": [], + "source": [ + "datay = r1.USyearly\n", + "datac = r1.UScum\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "f5deb8ac-708d-4bd1-876b-83995cbdac1a", + "metadata": {}, + "outputs": [], + "source": [ + "datay_CdTe = r2.USyearly\n", + "datac_CdTe = r2.UScum" + ] + }, + { + "cell_type": "markdown", + "id": "7f8613c4-c897-4bc3-8a5c-e42f8d94dab9", + "metadata": {}, + "source": [ + "### Get the EOL waste" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "a135352a-eba6-4723-b2cf-8ff87f3eb440", + "metadata": {}, + "outputs": [], + "source": [ + "filter_colc = [col for col in datay if col.startswith('WasteEOL')]\n", + "datay[filter_colc].to_csv(f'PVICE_PCA_cSi_WasteEOL_{projectionmethod}.csv')\n", + "filter_colc = [col for col in datay_CdTe if col.startswith('WasteEOL')]\n", + "datay_CdTe[filter_colc].to_csv(f'PVICE_PCA_CdTe_WasteEOL_{projectionmethod}.csv')" + ] + }, + { + "cell_type": "markdown", + "id": "69528c09-1c56-4f6b-8182-83a1a4db9d01", + "metadata": {}, + "source": [ + "### Get the Virgin materials" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "9d25f515-50ad-42ad-9e12-99b39ef5dbc6", + "metadata": {}, + "outputs": [], + "source": [ + "filter_colc = [col for col in datay if col.startswith('VirginStock')]\n", + "datay[filter_colc].to_csv(f'PVICE_PCA_cSi_VirginStock_{projectionmethod}.csv')\n", + "filter_colc = [col for col in datay_CdTe if col.startswith('VirginStock')]\n", + "datay_CdTe[filter_colc].to_csv(f'PVICE_PCA_CdTe_VirginStock_{pv_ice_simulations}.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0bc89327-de1d-4f7b-ac42-0847085d00da", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}