-
In [ ]:
+In [1]:
#setup
@@ -14605,8 +14605,8 @@ SIPS: QUIP SERIEScwd = os.getcwd() #grabs current working directory
-testfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'TEMP' / 'MESC-NRELStdScens')
-inputfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines'/'NRELStdScenarios')
+testfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'TEMP' / 'SIPS-Repowering')
+#inputfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines'/'NRELStdScenarios')
baselinesfolder = str(Path().resolve().parent.parent /'PV_ICE' / 'baselines')
supportMatfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines' / 'SupportingMaterial')
#altBaselinesfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines' / 'Energy_CellModuleTechCompare')
@@ -14625,12 +14625,38 @@ SIPS: QUIP SERIES
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Python version 3.11.5 | packaged by Anaconda, Inc. | (main, Sep 11 2023, 13:26:23) [MSC v.1916 64 bit (AMD64)]
+Pandas version 2.0.3
+pyplot 3.7.2
+PV_ICE version
+
+
+
+
+
+
+
+
+
-
+
In [ ]:
+In [2]:
sim1 = PV_ICE.Simulation(name='SIPS', path=testfolder)
@@ -14641,6 +14667,30 @@ SIPS: QUIP SERIES
+
+
+
+
+
+
+
+
+
+
+
+
+
+path = C:\Users\hmirletz\Documents\GitHub\PV_ICE\PV_ICE\TEMP\SIPS-Repowering
+Baseline folder directed to default: C:\Users\hmirletz\Documents\GitHub\PV_ICE\PV_ICE\baselines
+
+
+
+
+
+
+
-
In [ ]:
+In [3]:
#c-Si
MATERIALS = ['glass','aluminium_frames','silver','silicon', 'copper', 'encapsulant', 'backsheet']
-moduleFile = os.path.join(baselinesfolder, 'baseline_modules_mass_US_updatedT50T90.csv')
+moduleFile_m = os.path.join(baselinesfolder, 'baseline_modules_mass_US_updatedT50T90.csv')
+moduleFile_e = os.path.join(baselinesfolder, 'baseline_modules_energy.csv')
+
#CdTe
#MATERIALS_CdTe = ['glass_cdte','aluminium_frames_cdte', 'copper_cdte', 'encapsulant_cdte','cadmium','tellurium']
#moduleFile_CdTe = os.path.join(baselinesfolder, 'baseline_modules_mass_US_CdTe.csv')
@@ -14679,7 +14731,7 @@ Residential Case Study
-
In [ ]:
+In [4]:
-
@@ -14723,14 +14776,15 @@
In [ ]:
+In [5]:
#Residential case study
-sim1.createScenario(name='Resi_keep', massmodulefile=moduleFile) #create the scenario, name and mod file attach
+sim1.createScenario(name='Resi_keep', massmodulefile=moduleFile_m, energymodulefile=moduleFile_e) #create the scenario, name and mod file attach
for mat in MATERIALS:
- materialfile = os.path.join(baselinesfolder, 'baseline_material_mass_'+str(mat)+'.csv')
- sim1.scenario['Resi_keep'].addMaterial(mat, massmatfile=materialfile) # add all materials listed in MATERIALS
+ materialfile_m = os.path.join(baselinesfolder, 'baseline_material_mass_'+str(mat)+'.csv')
+ materialfile_e = os.path.join(baselinesfolder, 'baseline_material_energy_'+str(mat)+'.csv')
+ sim1.scenario['Resi_keep'].addMaterial(mat, massmatfile=materialfile_m, energymatfile=materialfile_e) # add all materials listed in MATERIALS
Residential Case Study
-
@@ -14759,15 +14813,15 @@
In [ ]:
+In [6]:
#Residential case study
-sim1.createScenario(name='Resi_repower', massmodulefile=moduleFile) #create the scenario, name and mod file attach
+sim1.createScenario(name='Resi_repower', massmodulefile=moduleFile_m, energymodulefile=moduleFile_e) #create the scenario, name and mod file attach
for mat in MATERIALS:
materialfile = os.path.join(baselinesfolder, 'baseline_material_mass_'+str(mat)+'.csv')
- sim1.scenario['Resi_repower'].addMaterial(mat, massmatfile=materialfile) # add all materials listed in MATERIALS
+ materialfile_e = os.path.join(baselinesfolder, 'baseline_material_energy_'+str(mat)+'.csv')
+ sim1.scenario['Resi_repower'].addMaterial(mat, massmatfile=materialfile_m, energymatfile=materialfile_e) # add all materials listed in MATERIALS
CdTeRamp_full
-
@@ -14780,19 +14834,19 @@
In [ ]:
+In [7]:
#Modify the Scenario
-sim1.modifyScenario(scenarios='Resi_keep',stage='new_Installed_Capacity_[MW]', value=0)#, start_year=) #
+sim1.modifyScenario(scenarios='Resi_keep',stage='new_Installed_Capacity_[MW]', value=0, start_year=1995) #
#sim1.modifyScenario(scenarios='NAME',stage='new_Installed_Capacity_[MW]', value=0.005, start_year=2015) #5kW system installed in 2015
-sim1.scenario['Resi_keep'].dataIn_m.loc[2015, 'new_Installed_Capacity_[MW]'] = resi_sys1_size
-sim1.scenario['Resi_keep'].dataIn_m.loc[2015, 'mod_degradation'] = resi_sys1_deg
-sim1.scenario['Resi_keep'].dataIn_m.loc[2015, 'mod_lifetime'] = resi_sys1_life
+sim1.scenario['Resi_keep'].dataIn_m.loc[2015-1995, 'new_Installed_Capacity_[MW]'] = resi_sys1_size
+sim1.scenario['Resi_keep'].dataIn_m.loc[2015-1995, 'mod_degradation'] = resi_sys1_deg
+sim1.scenario['Resi_keep'].dataIn_m.loc[2015-1995, 'mod_lifetime'] = resi_sys1_life
CdTeRamp_full
-
@@ -14800,12 +14854,69 @@
+
In [ ]:
+In [8]:
#Modify the Scenario
-sim1.modifyScenario(scenarios='Resi_repower',stage='new_Installed_Capacity_[MW]', value=0)#, start_year=) #
+sim1.modifyScenario(scenarios='Resi_repower',stage='new_Installed_Capacity_[MW]', value=0, start_year=1995) #
#sim1.modifyScenario(scenarios='NAME',stage='new_Installed_Capacity_[MW]', value=0.005, start_year=2015) #5kW system installed in 2015
-sim1.scenario['Resi_repower'].dataIn_m.loc[2015, 'new_Installed_Capacity_[MW]'] = resi_sys1_size
-sim1.scenario['Resi_repower'].dataIn_m.loc[2015, 'mod_degradation'] = resi_sys1_deg
-sim1.scenario['Resi_repower'].dataIn_m.loc[2015, 'mod_lifetime'] = resi_sys1_life_repower
+sim1.scenario['Resi_repower'].dataIn_m.loc[2015-1995, 'new_Installed_Capacity_[MW]'] = resi_sys1_size
+sim1.scenario['Resi_repower'].dataIn_m.loc[2015-1995, 'mod_degradation'] = resi_sys1_deg
+sim1.scenario['Resi_repower'].dataIn_m.loc[2015-1995, 'mod_lifetime'] = resi_sys1_life_repower
-sim1.scenario['Resi_repower'].dataIn_m.loc[2024, 'new_Installed_Capacity_[MW]'] = resi_sys2_size
-sim1.scenario['Resi_repower'].dataIn_m.loc[2024, 'mod_degradation'] = resi_sys2_deg
-sim1.scenario['Resi_repower'].dataIn_m.loc[2024, 'mod_lifetime'] = resi_sys2_life
+sim1.scenario['Resi_repower'].dataIn_m.loc[2024-1995, 'new_Installed_Capacity_[MW]'] = resi_sys2_size
+sim1.scenario['Resi_repower'].dataIn_m.loc[2024-1995, 'mod_degradation'] = resi_sys2_deg
+sim1.scenario['Resi_repower'].dataIn_m.loc[2024-1995, 'mod_lifetime'] = resi_sys2_life
CdTeRamp_full
+
+
+
+
+
+
+
+In [9]:
+
+
+
+
+
+
+#extend the analysis period for full energy calc
+sim1.trim_Years(2010,2060)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Trimming and extending Resi_keep +Resi_keep glass : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_keep aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_keep silver : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_keep silicon : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_keep copper : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_keep encapsulant : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_keep backsheet : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_keep backsheet : Data trimmed for Mass, years now encompass 2010 to 2060 +Trimming and extending Resi_repower +Resi_repower glass : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_repower aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_repower silver : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_repower silicon : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_repower copper : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_repower encapsulant : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_repower backsheet : Data trimmed for Energy, years now encompass 2010 to 2060 +Resi_repower backsheet : Data trimmed for Mass, years now encompass 2010 to 2060 ++
-
In [ ]:
+In [10]:
+
+
+
+
+
+
+
+
+In [11]:
+
+
+
+
+
+
+plt.plot(sim1.scenario['Resi_keep'].dataIn_m.loc[:, 'year'],
+ sim1.scenario['Resi_keep'].dataIn_m.loc[:, 'new_Installed_Capacity_[MW]'])
+plt.plot(sim1.scenario['Resi_repower'].dataIn_m.loc[:, 'year'],
+ sim1.scenario['Resi_repower'].dataIn_m.loc[:, 'new_Installed_Capacity_[MW]'], ls='--')
+plt.ylim(0,0.01)
+plt.ylabel('Deployed [MW_dc]')
+plt.legend(['Keep','Repower'])
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Out[11]:
+
+
+
+
+
+
+
+<matplotlib.legend.Legend at 0x1bd577ff450>+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+In [12]:
+
+
+
+
+
+
+sim1.calculateFlows()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+>>>> Calculating Material Flows <<<< + +Working on Scenario: Resi_keep +******************** +Finished Area+Power Generation Calculations +==> Working on Material : glass +Recycled surplus End of Sim for Mat glass Scenario Resi_keep = 6.923027231999998e-05 tonnes. +==> Working on Material : aluminium_frames +Recycled surplus End of Sim for Mat aluminium_frames Scenario Resi_keep = 0.0012234953067535056 tonnes. +==> Working on Material : silver +==> Working on Material : silicon +==> Working on Material : copper +==> Working on Material : encapsulant +==> Working on Material : backsheet +Working on Scenario: Resi_repower +******************** +Finished Area+Power Generation Calculations +==> Working on Material : glass +==> Working on Material : aluminium_frames +==> Working on Material : silver +==> Working on Material : silicon +==> Working on Material : copper +==> Working on Material : encapsulant +==> Working on Material : backsheet + + +>>>> Calculating Energy Flows <<<< + +Working on Scenario: Resi_keep +******************** +==> Working on Energy for Material : glass +==> Working on Energy for Material : aluminium_frames +==> Working on Energy for Material : silver +==> Working on Energy for Material : silicon +==> Working on Energy for Material : copper +==> Working on Energy for Material : encapsulant +==> Working on Energy for Material : backsheet +Working on Scenario: Resi_repower +******************** +==> Working on Energy for Material : glass +==> Working on Energy for Material : aluminium_frames +==> Working on Energy for Material : silver +==> Working on Energy for Material : silicon +==> Working on Energy for Material : copper +==> Working on Energy for Material : encapsulant +==> Working on Energy for Material : backsheet ++
+
+
+
+
+
+
+
+In [13]:
+
+
+
+
+
+
+sim1_yearly, sim1_cumu = sim1.aggregateResults()
+sim1_allenergy, sim1_energyGen, sim1_energyDemands_all = sim1.aggregateEnergyResults()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+C:\Users\hmirletz\Documents\GitHub\PV_ICE\PV_ICE\main.py:2263: SettingWithCopyWarning: +A value is trying to be set on a copy of a slice from a DataFrame. +Try using .loc[row_indexer,col_indexer] = value instead + +See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy + scende_demands.loc[:,colname] = scende_demands.sum(axis=1) #sums module and material energy demands +C:\Users\hmirletz\Documents\GitHub\PV_ICE\PV_ICE\main.py:2263: SettingWithCopyWarning: +A value is trying to be set on a copy of a slice from a DataFrame. +Try using .loc[row_indexer,col_indexer] = value instead + +See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy + scende_demands.loc[:,colname] = scende_demands.sum(axis=1) #sums module and material energy demands ++
+
+
+
+
+
+
+
+In [19]:
+
+
+
+
+
+
+decommisioned = sim1_yearly.filter(like='Decommisioned')
+plt.plot(decommisioned*1000)
+plt.legend(['Keep','Repower'])
+plt.ylim(0,14)
+plt.ylabel('Decommissioned Capacity [kW_dc]')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Out[19]:
+
+
+
+
+
+
+
+Text(0, 0.5, 'Decommissioned Capacity [kW_dc]')+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+In [15]:
+
+
+
+
+
+
+plt.plot(sim1_energyGen/1e6)
+plt.legend(['Keep','Repower'])
+plt.ylim(0,12.0)
+plt.ylabel('Annual Energy Generation [MWh]')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Out[15]:
+
+
+
+
+
+
+
+Text(0, 0.5, 'Annual Energy Generation [MWh]')+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+In [72]:
+
+
+
+
+
+
+cumu_energy_gen = sim1_energyGen.cumsum().loc[[2060]]
+cumu_energy_gen_MWh = cumu_energy_gen/1e6
+cumu_energy_gen_MWh.columns = ['Keep_[MWh]', 'Repower_[MWh]']
+cumu_energy_gen_MWh.index=['Energy_Gen']
+cumu_energy_gen_MWh
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Out[72]:
+
+
+
+
+
+
+
+
+
+
+
+
+| + | Keep_[MWh] | +Repower_[MWh] | +
|---|---|---|
| Energy_Gen | +148.307821 | +365.792917 | +
+
+
+
+
+
+
+
+In [73]:
+
+
+
+
+
+
+#sum the energy demands
+energydemand_keep = sim1_energyDemands_all.filter(like='keep').sum(axis=1).sum()/1e6 #MWh
+energydemand_repower = sim1_energyDemands_all.filter(like='repower').sum(axis=1).sum()/1e6 #MWh
+
+
+
+
+
+
+
+
+In [75]:
+
+
+
+
+
+
+cumu_energy_MWh = cumu_energy_gen_MWh.copy()
+cumu_energy_MWh.loc['Energy_Demand','Keep_[MWh]'] = energydemand_keep
+cumu_energy_MWh.loc['Energy_Demand','Repower_[MWh]'] = energydemand_repower
+cumu_energy_MWh
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Out[75]:
+
+
+
+
+
+
+
+
+
+
+
+
+| + | Keep_[MWh] | +Repower_[MWh] | +
|---|---|---|
| Energy_Gen | +148.307821 | +365.792917 | +
| Energy_Demand | +22.049576 | +35.809028 | +
+
+
+
+
+
+
+
+In [78]:
+
+
+
+
+
+
+#EROI
+cumu_energy_MWh.loc['EROI'] = cumu_energy_MWh.loc['Energy_Gen']/cumu_energy_MWh.loc['Energy_Demand']
+cumu_energy_MWh
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Out[78]:
+
+
+
+
+
+
+
+
+
+
+
+
+| + | Keep_[MWh] | +Repower_[MWh] | +
|---|---|---|
| Energy_Gen | +148.307821 | +365.792917 | +
| Energy_Demand | +22.049576 | +35.809028 | +
| EROI | +6.726108 | +10.215103 | +
+
+
+
+
+
+
+
+In [50]:
+
+
+
+
+
+
+#material demands
+modmass_keep = sim1_yearly.loc[2015,'VirginStock_Module_SIPS_Resi_keep_[Tonnes]']
+modmass_repower = sim1_yearly.loc[:,'VirginStock_Module_SIPS_Resi_repower_[Tonnes]'].sum()
+
+
+
+
+
+
+
+In [ ]:
+
+
+
+
+
+
+
+
diff --git a/docs/dev/SIPS2025-CaseStudies.ipynb b/docs/dev/SIPS2025-CaseStudies.ipynb
index 87e55ef..69e0682 100644
--- a/docs/dev/SIPS2025-CaseStudies.ipynb
+++ b/docs/dev/SIPS2025-CaseStudies.ipynb
@@ -11,10 +11,21 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 1,
"id": "51c46971-8cdf-4836-8418-0469123f3ab9",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Python version 3.11.5 | packaged by Anaconda, Inc. | (main, Sep 11 2023, 13:26:23) [MSC v.1916 64 bit (AMD64)]\n",
+ "Pandas version 2.0.3\n",
+ "pyplot 3.7.2\n",
+ "PV_ICE version \n"
+ ]
+ }
+ ],
"source": [
"#setup\n",
"import numpy as np\n",
@@ -28,8 +39,8 @@
"\n",
"cwd = os.getcwd() #grabs current working directory\n",
"\n",
- "testfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'TEMP' / 'MESC-NRELStdScens')\n",
- "inputfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines'/'NRELStdScenarios')\n",
+ "testfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'TEMP' / 'SIPS-Repowering')\n",
+ "#inputfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines'/'NRELStdScenarios')\n",
"baselinesfolder = str(Path().resolve().parent.parent /'PV_ICE' / 'baselines')\n",
"supportMatfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines' / 'SupportingMaterial')\n",
"#altBaselinesfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines' / 'Energy_CellModuleTechCompare')\n",
@@ -45,10 +56,19 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 2,
"id": "613f82f3-f393-43dc-9386-0b9329ab0804",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "path = C:\\Users\\hmirletz\\Documents\\GitHub\\PV_ICE\\PV_ICE\\TEMP\\SIPS-Repowering\n",
+ "Baseline folder directed to default: C:\\Users\\hmirletz\\Documents\\GitHub\\PV_ICE\\PV_ICE\\baselines\n"
+ ]
+ }
+ ],
"source": [
"sim1 = PV_ICE.Simulation(name='SIPS', path=testfolder)"
]
@@ -64,14 +84,16 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 3,
"id": "93a52417-0815-46cc-8b4f-c86fc2b6e556",
"metadata": {},
"outputs": [],
"source": [
"#c-Si\n",
"MATERIALS = ['glass','aluminium_frames','silver','silicon', 'copper', 'encapsulant', 'backsheet']\n",
- "moduleFile = os.path.join(baselinesfolder, 'baseline_modules_mass_US_updatedT50T90.csv')\n",
+ "moduleFile_m = os.path.join(baselinesfolder, 'baseline_modules_mass_US_updatedT50T90.csv')\n",
+ "moduleFile_e = os.path.join(baselinesfolder, 'baseline_modules_energy.csv')\n",
+ "\n",
"#CdTe\n",
"#MATERIALS_CdTe = ['glass_cdte','aluminium_frames_cdte', 'copper_cdte', 'encapsulant_cdte','cadmium','tellurium']\n",
"#moduleFile_CdTe = os.path.join(baselinesfolder, 'baseline_modules_mass_US_CdTe.csv')"
@@ -79,7 +101,7 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 4,
"id": "5ee5a3e3-29a3-4eea-94c5-e5ae75fb1da6",
"metadata": {},
"outputs": [],
@@ -97,30 +119,32 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 5,
"id": "efedbc4b-0216-48aa-a884-dbc8ce255975",
"metadata": {},
"outputs": [],
"source": [
"#Residential case study\n",
- "sim1.createScenario(name='Resi_keep', massmodulefile=moduleFile) #create the scenario, name and mod file attach\n",
+ "sim1.createScenario(name='Resi_keep', massmodulefile=moduleFile_m, energymodulefile=moduleFile_e) #create the scenario, name and mod file attach\n",
"for mat in MATERIALS:\n",
- " materialfile = os.path.join(baselinesfolder, 'baseline_material_mass_'+str(mat)+'.csv')\n",
- " sim1.scenario['Resi_keep'].addMaterial(mat, massmatfile=materialfile) # add all materials listed in MATERIALS"
+ " materialfile_m = os.path.join(baselinesfolder, 'baseline_material_mass_'+str(mat)+'.csv')\n",
+ " materialfile_e = os.path.join(baselinesfolder, 'baseline_material_energy_'+str(mat)+'.csv')\n",
+ " sim1.scenario['Resi_keep'].addMaterial(mat, massmatfile=materialfile_m, energymatfile=materialfile_e) # add all materials listed in MATERIALS"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 6,
"id": "7be01ab2-6824-4687-a1b8-23b68dbeb4ac",
"metadata": {},
"outputs": [],
"source": [
"#Residential case study\n",
- "sim1.createScenario(name='Resi_repower', massmodulefile=moduleFile) #create the scenario, name and mod file attach\n",
+ "sim1.createScenario(name='Resi_repower', massmodulefile=moduleFile_m, energymodulefile=moduleFile_e) #create the scenario, name and mod file attach\n",
"for mat in MATERIALS:\n",
" materialfile = os.path.join(baselinesfolder, 'baseline_material_mass_'+str(mat)+'.csv')\n",
- " sim1.scenario['Resi_repower'].addMaterial(mat, massmatfile=materialfile) # add all materials listed in MATERIALS"
+ " materialfile_e = os.path.join(baselinesfolder, 'baseline_material_energy_'+str(mat)+'.csv')\n",
+ " sim1.scenario['Resi_repower'].addMaterial(mat, massmatfile=materialfile_m, energymatfile=materialfile_e) # add all materials listed in MATERIALS"
]
},
{
@@ -138,48 +162,511 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 7,
"id": "61014a62-9b16-431d-9c5e-3aa2f19acef6",
"metadata": {},
"outputs": [],
"source": [
"#Modify the Scenario \n",
- "sim1.modifyScenario(scenarios='Resi_keep',stage='new_Installed_Capacity_[MW]', value=0)#, start_year=) #\n",
+ "sim1.modifyScenario(scenarios='Resi_keep',stage='new_Installed_Capacity_[MW]', value=0, start_year=1995) #\n",
"#sim1.modifyScenario(scenarios='NAME',stage='new_Installed_Capacity_[MW]', value=0.005, start_year=2015) #5kW system installed in 2015\n",
- "sim1.scenario['Resi_keep'].dataIn_m.loc[2015, 'new_Installed_Capacity_[MW]'] = resi_sys1_size\n",
- "sim1.scenario['Resi_keep'].dataIn_m.loc[2015, 'mod_degradation'] = resi_sys1_deg\n",
- "sim1.scenario['Resi_keep'].dataIn_m.loc[2015, 'mod_lifetime'] = resi_sys1_life\n"
+ "sim1.scenario['Resi_keep'].dataIn_m.loc[2015-1995, 'new_Installed_Capacity_[MW]'] = resi_sys1_size\n",
+ "sim1.scenario['Resi_keep'].dataIn_m.loc[2015-1995, 'mod_degradation'] = resi_sys1_deg\n",
+ "sim1.scenario['Resi_keep'].dataIn_m.loc[2015-1995, 'mod_lifetime'] = resi_sys1_life\n"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 8,
"id": "5ac8fa8a-7c2b-40ee-8b64-5c1e34594d6f",
"metadata": {},
"outputs": [],
"source": [
"#Modify the Scenario \n",
- "sim1.modifyScenario(scenarios='Resi_repower',stage='new_Installed_Capacity_[MW]', value=0)#, start_year=) #\n",
+ "sim1.modifyScenario(scenarios='Resi_repower',stage='new_Installed_Capacity_[MW]', value=0, start_year=1995) #\n",
"#sim1.modifyScenario(scenarios='NAME',stage='new_Installed_Capacity_[MW]', value=0.005, start_year=2015) #5kW system installed in 2015\n",
- "sim1.scenario['Resi_repower'].dataIn_m.loc[2015, 'new_Installed_Capacity_[MW]'] = resi_sys1_size\n",
- "sim1.scenario['Resi_repower'].dataIn_m.loc[2015, 'mod_degradation'] = resi_sys1_deg\n",
- "sim1.scenario['Resi_repower'].dataIn_m.loc[2015, 'mod_lifetime'] = resi_sys1_life_repower\n",
+ "sim1.scenario['Resi_repower'].dataIn_m.loc[2015-1995, 'new_Installed_Capacity_[MW]'] = resi_sys1_size\n",
+ "sim1.scenario['Resi_repower'].dataIn_m.loc[2015-1995, 'mod_degradation'] = resi_sys1_deg\n",
+ "sim1.scenario['Resi_repower'].dataIn_m.loc[2015-1995, 'mod_lifetime'] = resi_sys1_life_repower\n",
"\n",
- "sim1.scenario['Resi_repower'].dataIn_m.loc[2024, 'new_Installed_Capacity_[MW]'] = resi_sys2_size\n",
- "sim1.scenario['Resi_repower'].dataIn_m.loc[2024, 'mod_degradation'] = resi_sys2_deg\n",
- "sim1.scenario['Resi_repower'].dataIn_m.loc[2024, 'mod_lifetime'] = resi_sys2_life"
+ "sim1.scenario['Resi_repower'].dataIn_m.loc[2024-1995, 'new_Installed_Capacity_[MW]'] = resi_sys2_size\n",
+ "sim1.scenario['Resi_repower'].dataIn_m.loc[2024-1995, 'mod_degradation'] = resi_sys2_deg\n",
+ "sim1.scenario['Resi_repower'].dataIn_m.loc[2024-1995, 'mod_lifetime'] = resi_sys2_life"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 9,
+ "id": "4e2d9061-0112-4364-af82-fe4f8fc8110f",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Trimming and extending Resi_keep\n",
+ "Resi_keep glass : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_keep aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_keep silver : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_keep silicon : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_keep copper : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_keep encapsulant : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_keep backsheet : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_keep backsheet : Data trimmed for Mass, years now encompass 2010 to 2060\n",
+ "Trimming and extending Resi_repower\n",
+ "Resi_repower glass : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_repower aluminium_frames : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_repower silver : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_repower silicon : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_repower copper : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_repower encapsulant : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_repower backsheet : Data trimmed for Energy, years now encompass 2010 to 2060\n",
+ "Resi_repower backsheet : Data trimmed for Mass, years now encompass 2010 to 2060\n"
+ ]
+ }
+ ],
+ "source": [
+ "#extend the analysis period for full energy calc\n",
+ "sim1.trim_Years(2010,2060)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
"id": "6268306d-58bc-4065-9810-0871f6871744",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "#do we also need a reuse scenario where both systems are used for full life? - wouldn't it just be additive?\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "e791648b-0ccb-47aa-8b84-fcd97b12394c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(sim1.scenario['Resi_keep'].dataIn_m.loc[:, 'year'], \n",
+ " sim1.scenario['Resi_keep'].dataIn_m.loc[:, 'new_Installed_Capacity_[MW]'])\n",
+ "plt.plot(sim1.scenario['Resi_repower'].dataIn_m.loc[:, 'year'], \n",
+ " sim1.scenario['Resi_repower'].dataIn_m.loc[:, 'new_Installed_Capacity_[MW]'], ls='--')\n",
+ "plt.ylim(0,0.01)\n",
+ "plt.ylabel('Deployed [MW_dc]')\n",
+ "plt.legend(['Keep','Repower'])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "828595fe-ad41-40a2-9c90-7e59e4968a35",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ ">>>> Calculating Material Flows <<<<\n",
+ "\n",
+ "Working on Scenario: Resi_keep\n",
+ "********************\n",
+ "Finished Area+Power Generation Calculations\n",
+ "==> Working on Material : glass\n",
+ "Recycled surplus End of Sim for Mat glass Scenario Resi_keep = 6.923027231999998e-05 tonnes.\n",
+ "==> Working on Material : aluminium_frames\n",
+ "Recycled surplus End of Sim for Mat aluminium_frames Scenario Resi_keep = 0.0012234953067535056 tonnes.\n",
+ "==> Working on Material : silver\n",
+ "==> Working on Material : silicon\n",
+ "==> Working on Material : copper\n",
+ "==> Working on Material : encapsulant\n",
+ "==> Working on Material : backsheet\n",
+ "Working on Scenario: Resi_repower\n",
+ "********************\n",
+ "Finished Area+Power Generation Calculations\n",
+ "==> Working on Material : glass\n",
+ "==> Working on Material : aluminium_frames\n",
+ "==> Working on Material : silver\n",
+ "==> Working on Material : silicon\n",
+ "==> Working on Material : copper\n",
+ "==> Working on Material : encapsulant\n",
+ "==> Working on Material : backsheet\n",
+ "\n",
+ "\n",
+ ">>>> Calculating Energy Flows <<<<\n",
+ "\n",
+ "Working on Scenario: Resi_keep\n",
+ "********************\n",
+ "==> Working on Energy for Material : glass\n",
+ "==> Working on Energy for Material : aluminium_frames\n",
+ "==> Working on Energy for Material : silver\n",
+ "==> Working on Energy for Material : silicon\n",
+ "==> Working on Energy for Material : copper\n",
+ "==> Working on Energy for Material : encapsulant\n",
+ "==> Working on Energy for Material : backsheet\n",
+ "Working on Scenario: Resi_repower\n",
+ "********************\n",
+ "==> Working on Energy for Material : glass\n",
+ "==> Working on Energy for Material : aluminium_frames\n",
+ "==> Working on Energy for Material : silver\n",
+ "==> Working on Energy for Material : silicon\n",
+ "==> Working on Energy for Material : copper\n",
+ "==> Working on Energy for Material : encapsulant\n",
+ "==> Working on Energy for Material : backsheet\n"
+ ]
+ }
+ ],
+ "source": [
+ "sim1.calculateFlows()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "2e42289d-aded-4577-92c4-65ec1855d329",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "C:\\Users\\hmirletz\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2263: SettingWithCopyWarning: \n",
+ "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+ "Try using .loc[row_indexer,col_indexer] = value instead\n",
+ "\n",
+ "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+ " scende_demands.loc[:,colname] = scende_demands.sum(axis=1) #sums module and material energy demands\n",
+ "C:\\Users\\hmirletz\\Documents\\GitHub\\PV_ICE\\PV_ICE\\main.py:2263: SettingWithCopyWarning: \n",
+ "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+ "Try using .loc[row_indexer,col_indexer] = value instead\n",
+ "\n",
+ "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+ " scende_demands.loc[:,colname] = scende_demands.sum(axis=1) #sums module and material energy demands\n"
+ ]
+ }
+ ],
+ "source": [
+ "sim1_yearly, sim1_cumu = sim1.aggregateResults()\n",
+ "sim1_allenergy, sim1_energyGen, sim1_energyDemands_all = sim1.aggregateEnergyResults()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "6db33248-50a3-4274-a1b3-a9ced04a20e7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Text(0, 0.5, 'Decommissioned Capacity [kW_dc]')"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "decommisioned = sim1_yearly.filter(like='Decommisioned')\n",
+ "plt.plot(decommisioned*1000)\n",
+ "plt.legend(['Keep','Repower'])\n",
+ "plt.ylim(0,14)\n",
+ "plt.ylabel('Decommissioned Capacity [kW_dc]')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "eedd27d0-17da-4752-8479-1191cd246ead",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Text(0, 0.5, 'Annual Energy Generation [MWh]')"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(sim1_energyGen/1e6)\n",
+ "plt.legend(['Keep','Repower'])\n",
+ "plt.ylim(0,12.0)\n",
+ "plt.ylabel('Annual Energy Generation [MWh]')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 72,
+ "id": "5b55fdcd-bfc4-4742-a365-8816b5cc38a9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Keep_[MWh] Repower_[MWh]\n",
+ "Energy_Gen 148.307821 365.792917"
+ ]
+ },
+ "execution_count": 72,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "cumu_energy_gen = sim1_energyGen.cumsum().loc[[2060]]\n",
+ "cumu_energy_gen_MWh = cumu_energy_gen/1e6\n",
+ "cumu_energy_gen_MWh.columns = ['Keep_[MWh]', 'Repower_[MWh]']\n",
+ "cumu_energy_gen_MWh.index=['Energy_Gen']\n",
+ "cumu_energy_gen_MWh"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "id": "245df34e-ddc9-416c-9eb3-512ab8d8341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#sum the energy demands\n",
+ "energydemand_keep = sim1_energyDemands_all.filter(like='keep').sum(axis=1).sum()/1e6 #MWh\n",
+ "energydemand_repower = sim1_energyDemands_all.filter(like='repower').sum(axis=1).sum()/1e6 #MWh"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 75,
+ "id": "cce5ad74-8191-4b71-b4f1-dbea5c280317",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | Keep_[MWh] | \n", + "Repower_[MWh] | \n", + "
|---|---|---|
| Energy_Gen | \n", + "148.307821 | \n", + "365.792917 | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Keep_[MWh] Repower_[MWh]\n",
+ "Energy_Gen 148.307821 365.792917\n",
+ "Energy_Demand 22.049576 35.809028"
+ ]
+ },
+ "execution_count": 75,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "cumu_energy_MWh = cumu_energy_gen_MWh.copy()\n",
+ "cumu_energy_MWh.loc['Energy_Demand','Keep_[MWh]'] = energydemand_keep\n",
+ "cumu_energy_MWh.loc['Energy_Demand','Repower_[MWh]'] = energydemand_repower\n",
+ "cumu_energy_MWh"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 78,
+ "id": "6319d6ed-18d2-4869-8d66-4a307731c6d5",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | Keep_[MWh] | \n", + "Repower_[MWh] | \n", + "
|---|---|---|
| Energy_Gen | \n", + "148.307821 | \n", + "365.792917 | \n", + "
| Energy_Demand | \n", + "22.049576 | \n", + "35.809028 | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Keep_[MWh] Repower_[MWh]\n",
+ "Energy_Gen 148.307821 365.792917\n",
+ "Energy_Demand 22.049576 35.809028\n",
+ "EROI 6.726108 10.215103"
+ ]
+ },
+ "execution_count": 78,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#EROI\n",
+ "cumu_energy_MWh.loc['EROI'] = cumu_energy_MWh.loc['Energy_Gen']/cumu_energy_MWh.loc['Energy_Demand']\n",
+ "cumu_energy_MWh"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "id": "77030757-12bb-4e0e-834e-6a23fbd59d8c",
"metadata": {},
"outputs": [],
"source": [
- "#do we also need a reuse scenario where both systems are used for full life? - wouldn't it just be additive?"
+ "#material demands\n",
+ "modmass_keep = sim1_yearly.loc[2015,'VirginStock_Module_SIPS_Resi_keep_[Tonnes]']\n",
+ "modmass_repower = sim1_yearly.loc[:,'VirginStock_Module_SIPS_Resi_repower_[Tonnes]'].sum()\n"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "720d84de-79ee-45bc-976f-4d2261852ea4",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
{
"cell_type": "markdown",
"id": "b229bce9-496d-4f55-b8a1-2fd1158b3a75",
diff --git a/docs/dev/SIPS2025-CaseStudies.py b/docs/dev/SIPS2025-CaseStudies.py
index 1cd669a..a442903 100644
--- a/docs/dev/SIPS2025-CaseStudies.py
+++ b/docs/dev/SIPS2025-CaseStudies.py
@@ -4,7 +4,7 @@
# # SIPS: QUIP SERIES
# This journal explores the case studies of the SIPS 2025 project understanding the implications of repowering and module reuse. This compliments analyses conducted in SAM and PV Watts. Below are the Residential, Commercial, and Utility scale case studies
-# In[ ]:
+# In[1]:
#setup
@@ -19,8 +19,8 @@
cwd = os.getcwd() #grabs current working directory
-testfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'TEMP' / 'MESC-NRELStdScens')
-inputfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines'/'NRELStdScenarios')
+testfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'TEMP' / 'SIPS-Repowering')
+#inputfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines'/'NRELStdScenarios')
baselinesfolder = str(Path().resolve().parent.parent /'PV_ICE' / 'baselines')
supportMatfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines' / 'SupportingMaterial')
#altBaselinesfolder = str(Path().resolve().parent.parent / 'PV_ICE' / 'baselines' / 'Energy_CellModuleTechCompare')
@@ -34,7 +34,7 @@
print("PV_ICE version ", PV_ICE.__version__)
-# In[ ]:
+# In[2]:
sim1 = PV_ICE.Simulation(name='SIPS', path=testfolder)
@@ -43,18 +43,20 @@
# ## Residential Case Study
# This case study considers a residential system where the PV system is not at technical end of life (installed 2015), but the roof needs replacing in 2024. The owner has the option of keeping the old system or replacing the PV system.
-# In[ ]:
+# In[3]:
#c-Si
MATERIALS = ['glass','aluminium_frames','silver','silicon', 'copper', 'encapsulant', 'backsheet']
-moduleFile = os.path.join(baselinesfolder, 'baseline_modules_mass_US_updatedT50T90.csv')
+moduleFile_m = os.path.join(baselinesfolder, 'baseline_modules_mass_US_updatedT50T90.csv')
+moduleFile_e = os.path.join(baselinesfolder, 'baseline_modules_energy.csv')
+
#CdTe
#MATERIALS_CdTe = ['glass_cdte','aluminium_frames_cdte', 'copper_cdte', 'encapsulant_cdte','cadmium','tellurium']
#moduleFile_CdTe = os.path.join(baselinesfolder, 'baseline_modules_mass_US_CdTe.csv')
-# In[ ]:
+# In[4]:
#residential system parameters
@@ -68,24 +70,26 @@
resi_sys2_life = 30 #years of life
-# In[ ]:
+# In[5]:
#Residential case study
-sim1.createScenario(name='Resi_keep', massmodulefile=moduleFile) #create the scenario, name and mod file attach
+sim1.createScenario(name='Resi_keep', massmodulefile=moduleFile_m, energymodulefile=moduleFile_e) #create the scenario, name and mod file attach
for mat in MATERIALS:
- materialfile = os.path.join(baselinesfolder, 'baseline_material_mass_'+str(mat)+'.csv')
- sim1.scenario['Resi_keep'].addMaterial(mat, massmatfile=materialfile) # add all materials listed in MATERIALS
+ materialfile_m = os.path.join(baselinesfolder, 'baseline_material_mass_'+str(mat)+'.csv')
+ materialfile_e = os.path.join(baselinesfolder, 'baseline_material_energy_'+str(mat)+'.csv')
+ sim1.scenario['Resi_keep'].addMaterial(mat, massmatfile=materialfile_m, energymatfile=materialfile_e) # add all materials listed in MATERIALS
-# In[ ]:
+# In[6]:
#Residential case study
-sim1.createScenario(name='Resi_repower', massmodulefile=moduleFile) #create the scenario, name and mod file attach
+sim1.createScenario(name='Resi_repower', massmodulefile=moduleFile_m, energymodulefile=moduleFile_e) #create the scenario, name and mod file attach
for mat in MATERIALS:
materialfile = os.path.join(baselinesfolder, 'baseline_material_mass_'+str(mat)+'.csv')
- sim1.scenario['Resi_repower'].addMaterial(mat, massmatfile=materialfile) # add all materials listed in MATERIALS
+ materialfile_e = os.path.join(baselinesfolder, 'baseline_material_energy_'+str(mat)+'.csv')
+ sim1.scenario['Resi_repower'].addMaterial(mat, massmatfile=materialfile_m, energymatfile=materialfile_e) # add all materials listed in MATERIALS
# idx_temp = pd.RangeIndex(start=2024,stop=2051,step=1) #create the index
@@ -95,38 +99,138 @@
# CdTeRamp_full = round(CdTeRamp.interpolate(),0)
# #CdTeRamp_full
-# In[ ]:
+# In[7]:
#Modify the Scenario
-sim1.modifyScenario(scenarios='Resi_keep',stage='new_Installed_Capacity_[MW]', value=0)#, start_year=) #
+sim1.modifyScenario(scenarios='Resi_keep',stage='new_Installed_Capacity_[MW]', value=0, start_year=1995) #
#sim1.modifyScenario(scenarios='NAME',stage='new_Installed_Capacity_[MW]', value=0.005, start_year=2015) #5kW system installed in 2015
-sim1.scenario['Resi_keep'].dataIn_m.loc[2015, 'new_Installed_Capacity_[MW]'] = resi_sys1_size
-sim1.scenario['Resi_keep'].dataIn_m.loc[2015, 'mod_degradation'] = resi_sys1_deg
-sim1.scenario['Resi_keep'].dataIn_m.loc[2015, 'mod_lifetime'] = resi_sys1_life
+sim1.scenario['Resi_keep'].dataIn_m.loc[2015-1995, 'new_Installed_Capacity_[MW]'] = resi_sys1_size
+sim1.scenario['Resi_keep'].dataIn_m.loc[2015-1995, 'mod_degradation'] = resi_sys1_deg
+sim1.scenario['Resi_keep'].dataIn_m.loc[2015-1995, 'mod_lifetime'] = resi_sys1_life
-# In[ ]:
+# In[8]:
#Modify the Scenario
-sim1.modifyScenario(scenarios='Resi_repower',stage='new_Installed_Capacity_[MW]', value=0)#, start_year=) #
+sim1.modifyScenario(scenarios='Resi_repower',stage='new_Installed_Capacity_[MW]', value=0, start_year=1995) #
#sim1.modifyScenario(scenarios='NAME',stage='new_Installed_Capacity_[MW]', value=0.005, start_year=2015) #5kW system installed in 2015
-sim1.scenario['Resi_repower'].dataIn_m.loc[2015, 'new_Installed_Capacity_[MW]'] = resi_sys1_size
-sim1.scenario['Resi_repower'].dataIn_m.loc[2015, 'mod_degradation'] = resi_sys1_deg
-sim1.scenario['Resi_repower'].dataIn_m.loc[2015, 'mod_lifetime'] = resi_sys1_life_repower
+sim1.scenario['Resi_repower'].dataIn_m.loc[2015-1995, 'new_Installed_Capacity_[MW]'] = resi_sys1_size
+sim1.scenario['Resi_repower'].dataIn_m.loc[2015-1995, 'mod_degradation'] = resi_sys1_deg
+sim1.scenario['Resi_repower'].dataIn_m.loc[2015-1995, 'mod_lifetime'] = resi_sys1_life_repower
-sim1.scenario['Resi_repower'].dataIn_m.loc[2024, 'new_Installed_Capacity_[MW]'] = resi_sys2_size
-sim1.scenario['Resi_repower'].dataIn_m.loc[2024, 'mod_degradation'] = resi_sys2_deg
-sim1.scenario['Resi_repower'].dataIn_m.loc[2024, 'mod_lifetime'] = resi_sys2_life
+sim1.scenario['Resi_repower'].dataIn_m.loc[2024-1995, 'new_Installed_Capacity_[MW]'] = resi_sys2_size
+sim1.scenario['Resi_repower'].dataIn_m.loc[2024-1995, 'mod_degradation'] = resi_sys2_deg
+sim1.scenario['Resi_repower'].dataIn_m.loc[2024-1995, 'mod_lifetime'] = resi_sys2_life
-# In[ ]:
+# In[9]:
+
+
+#extend the analysis period for full energy calc
+sim1.trim_Years(2010,2060)
+
+
+# In[10]:
#do we also need a reuse scenario where both systems are used for full life? - wouldn't it just be additive?
+# In[11]:
+
+
+plt.plot(sim1.scenario['Resi_keep'].dataIn_m.loc[:, 'year'],
+ sim1.scenario['Resi_keep'].dataIn_m.loc[:, 'new_Installed_Capacity_[MW]'])
+plt.plot(sim1.scenario['Resi_repower'].dataIn_m.loc[:, 'year'],
+ sim1.scenario['Resi_repower'].dataIn_m.loc[:, 'new_Installed_Capacity_[MW]'], ls='--')
+plt.ylim(0,0.01)
+plt.ylabel('Deployed [MW_dc]')
+plt.legend(['Keep','Repower'])
+
+
+# In[12]:
+
+
+sim1.calculateFlows()
+
+
+# In[13]:
+
+
+sim1_yearly, sim1_cumu = sim1.aggregateResults()
+sim1_allenergy, sim1_energyGen, sim1_energyDemands_all = sim1.aggregateEnergyResults()
+
+
+# In[19]:
+
+
+decommisioned = sim1_yearly.filter(like='Decommisioned')
+plt.plot(decommisioned*1000)
+plt.legend(['Keep','Repower'])
+plt.ylim(0,14)
+plt.ylabel('Decommissioned Capacity [kW_dc]')
+
+
+# In[15]:
+
+
+plt.plot(sim1_energyGen/1e6)
+plt.legend(['Keep','Repower'])
+plt.ylim(0,12.0)
+plt.ylabel('Annual Energy Generation [MWh]')
+
+
+# In[72]:
+
+
+cumu_energy_gen = sim1_energyGen.cumsum().loc[[2060]]
+cumu_energy_gen_MWh = cumu_energy_gen/1e6
+cumu_energy_gen_MWh.columns = ['Keep_[MWh]', 'Repower_[MWh]']
+cumu_energy_gen_MWh.index=['Energy_Gen']
+cumu_energy_gen_MWh
+
+
+# In[73]:
+
+
+#sum the energy demands
+energydemand_keep = sim1_energyDemands_all.filter(like='keep').sum(axis=1).sum()/1e6 #MWh
+energydemand_repower = sim1_energyDemands_all.filter(like='repower').sum(axis=1).sum()/1e6 #MWh
+
+
+# In[75]:
+
+
+cumu_energy_MWh = cumu_energy_gen_MWh.copy()
+cumu_energy_MWh.loc['Energy_Demand','Keep_[MWh]'] = energydemand_keep
+cumu_energy_MWh.loc['Energy_Demand','Repower_[MWh]'] = energydemand_repower
+cumu_energy_MWh
+
+
+# In[78]:
+
+
+#EROI
+cumu_energy_MWh.loc['EROI'] = cumu_energy_MWh.loc['Energy_Gen']/cumu_energy_MWh.loc['Energy_Demand']
+cumu_energy_MWh
+
+
+# In[50]:
+
+
+#material demands
+modmass_keep = sim1_yearly.loc[2015,'VirginStock_Module_SIPS_Resi_keep_[Tonnes]']
+modmass_repower = sim1_yearly.loc[:,'VirginStock_Module_SIPS_Resi_repower_[Tonnes]'].sum()
+
+
+# In[ ]:
+
+
+
+
+
# # Commercial Case Study
# This case study considers a set of commerical PV installations.
| \n", + " | Keep_[MWh] | \n", + "Repower_[MWh] | \n", + "
|---|---|---|
| Energy_Gen | \n", + "148.307821 | \n", + "365.792917 | \n", + "
| Energy_Demand | \n", + "22.049576 | \n", + "35.809028 | \n", + "
| EROI | \n", + "6.726108 | \n", + "10.215103 | \n", + "