diff --git a/README.md b/README.md
index 1ca9ea9..65abfe5 100644
--- a/README.md
+++ b/README.md
@@ -15,24 +15,19 @@ to test:
> import temoatools as tt
# Stochastic optimization
-Instructions to run examples/puerto_rico_stoch:
+Instructions to run examples/puerto_rico_stoch.
1) Install python and required packages
1) Install python 2.7 (using anaconda2), https://www.anaconda.com/distribution/#download-section
2) Install pyomo version 4.3 (using anaconda2 prompt)
>pip install pyomo==4.3
3) Update pyomo using legacy files
- 1) Go to the temoa_stochastic/legacy_files folder to find ef_writer_script_old.py.
+ 1) Go to the temoa_stochastic/tools/legacy_files folder to find ef_writer_script_old.py.
Copy paste this script at: ../anaconda/lib/python2.7/site-packages/pyomo/pysp
- 2) Go to the temoa_stochastic/legacy_files folder to find scenariomodels.py.
+ 2) Go to the temoa_stochastic/tools/legacy_files folder to find scenariomodels.py.
Copy paste this script at: ../anaconda/lib/python2.7/site-packages/pyomo/pysp/util
- 4) Install temoa
- 1) copy temoa_stochastic folder to C:\\temoa_stochastic
- 2) Change directory to the temoa folder
- >cd C:\\temoa_stochastic
- 2) Install using pip command
- >pip install .
- 5) Install temoatools (instructions above)
+ 4) Install temoatools (instructions above). This will include copying a version of temoa (temoa_stochastic) that has been modified for this analysis
+ 5) Install a linear solver such as CPLEX, additional information can be found here: https://temoacloud.com/download/
2) Enter/update simulation data in examples/puerto_rico_stoch/data folder. Scenarios_overview.ppt/.pdf provides background on cases simulated
1) paths.xls - provides paths to anaconda2 and temoa installation
diff --git a/temoa_stochastic/LICENSE.txt b/temoa_stochastic/LICENSE.txt
new file mode 100644
index 0000000..6c5b18c
--- /dev/null
+++ b/temoa_stochastic/LICENSE.txt
@@ -0,0 +1,280 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc., (Optional -o )\n Use -h for help."
+ sys.exit(2)
+ else :
+ file_type = re.search(r"(\w+)\.(\w+)\b", ifile) # Extract the input filename and extension
+ if not file_type :
+ print "The file type %s is not recognized. Use a db file." % ifile
+ sys.exit(2)
+ if ofile is None :
+ ofile = file_type.group(1)
+ print "Look for output in %s_*.xls" % ofile
+
+
+ con = sqlite3.connect(ifile)
+ cur = con.cursor() # a database cursor is a control structure that enables traversal over the records in a database
+ con.text_factory = str #this ensures data is explored with the correct UTF-8 encoding
+
+ for k in tables.keys() :
+ if not scenario :
+ cur.execute("SELECT DISTINCT scenario FROM "+k)
+ for val in cur :
+ scenario.add(val[0])
+
+ for axy in cur.execute("SELECT count(*) FROM sqlite_master WHERE type='table' AND name='technologies';") :
+ if axy[0] :
+ fields = [ads[1] for ads in cur.execute('PRAGMA table_info(technologies)')]
+ if 'sector' in fields :
+ cur.execute("SELECT sector FROM technologies")
+ for val in cur :
+ sector.add(val[0])
+ if not sector :
+ sector.add('0')
+ else :
+ flag = 1
+
+ if flag is None :
+ cur.execute("SELECT DISTINCT tech FROM "+k)
+ for val in cur :
+ tech['0'].append(val[0])
+ tech_set.add(val[0])
+ else :
+ for x in sector :
+ cur.execute("SELECT DISTINCT tech FROM technologies WHERE sector is '"+x+"'")
+ for val in cur :
+ if val[0] not in tech[x] :
+ tech[x].append(val[0])
+ tech_set.add(val[0])
+
+ if k is "Output_Emissions" :
+ cur.execute("SELECT DISTINCT emissions_comm FROM "+k)
+ for val in cur :
+ emiss.add(val[0])
+
+ if k is "Output_Costs" :
+ pass
+ else:#if k is not "Output_V_Capacity":
+ cur.execute("SELECT DISTINCT t_periods FROM "+k)
+ for val in cur :
+ val = str(val[0])
+ if val not in period :
+ period.append(val)
+ header.append(val)
+ header[1:].sort()
+ period.sort()
+ header_emiss = header[:]
+ header_emiss.insert(1, "Emission Commodity")
+
+ ostyle = easyxf('alignment: vertical centre, horizontal centre;')
+ ostyle_header = easyxf('alignment: vertical centre, horizontal centre, wrap True;')
+
+ for scene in scenario :
+ book.append(xlwt.Workbook(encoding="utf-8"))
+ for z in sector :
+ for a in tables.keys() :
+ if z is '0' :
+ sheet_name = str(tables[a][0])
+ if a is "Output_Costs" :
+ flag2 = '1'
+ if a is "Output_Emissions" :
+ flag1 = '1'
+ elif (a is "Output_Costs" and flag2 is None) :
+ sheet_name = str(tables[a][0])
+ flag2 = '1'
+ elif (a is "Output_Emissions" and flag1 is None) :
+ sheet_name = str(tables[a][0])
+ flag1 = '1'
+ elif (a is "Output_Costs" and flag2 is not None) or (a is "Output_Emissions" and flag1 is not None) :
+ continue
+ else :
+ sheet_name = str(tables[a][0])+"_"+str(z)
+ sheet.append(book[book_no].add_sheet(sheet_name))
+ if a is "Output_Emissions" and flag1 is '1':
+ for col in range(0, len(header_emiss)) :
+ sheet[i].write(row, col, header_emiss[col], ostyle_header)
+ sheet[i].col(col).width_in_pixels = 3300
+ row += 1
+ for x in tech_set :
+ for q in emiss :
+ sheet[i].write(row, 0, x, ostyle)
+ sheet[i].write(row, 1, q, ostyle)
+ for y in period :
+ cur.execute("SELECT sum("+tables[a][1]+") FROM "+a+" WHERE t_periods is '"+y+"' and scenario is '"+scene+"' and tech is '"+x+"' and emissions_comm is '"+q+"'")
+ xyz = cur.fetchone()
+ if xyz[0] is not None :
+ sheet[i].write(row, count+2, float(xyz[0]), ostyle)
+ else :
+ sheet[i].write(row, count+2, '-', ostyle)
+ count += 1
+ row += 1
+ count = 0
+ row = 0
+ i += 1
+ flag1 = '2'
+ elif a is "Output_Costs" and flag2 is '1':
+ for col in range(0, len(header_v)) :
+ sheet[i].write(row, col, header_v[col], ostyle_header)
+ sheet[i].col(col).width_in_pixels = 3300
+ row += 1
+ for x in tech_set :
+ cur.execute("SELECT output_name, vintage, "+tables[a][1]+" FROM "+a+" WHERE scenario is '"+scene+"' and tech is '"+x+"'")
+ for xyz in cur :
+ if xyz[0] is not None :
+ sheet[i].write(row, 0, x, ostyle)
+ sheet[i].write(row, count+1, xyz[0], ostyle)
+ sheet[i].write(row, count+2, xyz[1], ostyle)
+ sheet[i].write(row, count+3, xyz[2], ostyle)
+ else :
+ sheet[i].write(row, 0, x, ostyle)
+ sheet[i].write(row, count+1, '-', ostyle)
+ sheet[i].write(row, count+2, '-', ostyle)
+ sheet[i].write(row, count+3, '-', ostyle)
+ row += 1
+ count = 0
+ row = 0
+ i += 1
+ flag2 = '2'
+ elif (a is "Output_Costs" and flag2 is '2') or (a is "Output_Emissions" and flag1 is '2'):
+ pass
+ elif a is not "Output_V_Capacity":
+ for col in range(0, len(header)) :
+ sheet[i].write(row, col, header[col], ostyle_header)
+ sheet[i].col(col).width_in_pixels = 3300
+ row += 1
+ for x in tech[z] :
+ sheet[i].write(row, 0, x, ostyle)
+ for y in period :
+ cur.execute("SELECT sum("+tables[a][1]+") FROM "+a+" WHERE t_periods is '"+y+"' and scenario is '"+scene+"' and tech is '"+x+"'")
+ xyz = cur.fetchone()
+ if xyz[0] is not None :
+ sheet[i].write(row, count+1, float(xyz[0]), ostyle)
+ else :
+ sheet[i].write(row, count+1, '-', ostyle)
+ count += 1
+ row += 1
+ count = 0
+ row = 0
+ i += 1
+ if len(scenario) is 1:
+ book[book_no].save(ofile+".xls")
+ else :
+ book[book_no].save(ofile+"_"+scene+".xls")
+ book_no += 1
+ flag1 = None
+ flag2 = None
+
+ cur.close()
+ con.close()
+
+
+def get_data(inputs):
+
+ ifile = None
+ ofile = None
+ scenario = set()
+
+ if inputs is None:
+ raise "no arguments found"
+
+ for opt, arg in inputs.iteritems():
+ if opt in ("-i", "--input"):
+ ifile = arg
+ elif opt in ("-o", "--output"):
+ ofile = arg
+ elif opt in ("-s", "--scenario"):
+ scenario.add(arg)
+ elif opt in ("-h", "--help") :
+ print "Use as :\n python DB_to_Excel.py -i (Optional -o )\n Use -h for help."
+ sys.exit()
+
+ make_excel(ifile, ofile, scenario)
+
+if __name__ == "__main__":
+
+ try:
+ argv = sys.argv[1:]
+ opts, args = getopt.getopt(argv, "hi:o:s:", ["help", "input=", "output=", "scenario="])
+ except getopt.GetoptError:
+ print "Something's Wrong. Use as :\n python DB_to_Excel.py -i (Optional -o )\n Use -h for help."
+ sys.exit(2)
+
+ print opts
+
+ get_data( dict(opts) )
diff --git a/temoa_stochastic/temoa_model/ReferenceModel.py b/temoa_stochastic/temoa_model/ReferenceModel.py
new file mode 100644
index 0000000..9f36ff6
--- /dev/null
+++ b/temoa_stochastic/temoa_model/ReferenceModel.py
@@ -0,0 +1,206 @@
+#!/usr/bin/env python
+
+"""
+Tools for Energy Model Optimization and Analysis (Temoa):
+An open source framework for energy systems optimization modeling
+
+Copyright (C) 2015, NC State University
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+A complete copy of the GNU General Public License v2 (GPLv2) is available
+in LICENSE.txt. Users uncompressing this from an archive may not have
+received this license file. If not, see operates.
+
+For most processes and periods, this will likely be one, but for any process
+that will cease operation (rust out, be decommissioned, etc.) between periods,
+calculate the fraction of the period that the technology is able to
+create useful output.
+"""
+ eol_year = v + value( M.LifetimeProcess[t, v] )
+ frac = eol_year - p
+ period_length = value( M.PeriodLength[ p ] )
+ if frac >= period_length:
+ # try to avoid floating point round-off errors for the common case.
+ return 1
+
+ # number of years into final period loan is complete
+
+ frac /= float( period_length )
+ return frac
+
+
+def ParamLoanAnnualize_rule ( M, t, v ):
+ dr = value( M.DiscountRate[t, v] )
+ lln = value( M.LifetimeLoanProcess[t, v] )
+ if not dr:
+ return 1.0 / lln
+ annualized_rate = ( dr / (1.0 - (1.0 + dr)**(-lln) ))
+
+ return annualized_rate
+
+# End initialization rules
+##############################################################################
+
+##############################################################################
+# Constraint rules
+
+def BaseloadDiurnal_Constraint ( M, p, s, d, t, v ):
+ r"""
+There exists within the electric sector a class of technologies whose
+thermodynamic properties are impossible to change over a short period of time
+(e.g. hourly or daily). These include coal and nuclear power plants, which
+take weeks to bring to an operational state, and similarly require weeks to
+fully shut down. Temoa models this behavior by forcing technologies in the
+:code:`tech_baseload` set to maintain a constant output for all daily slices.
+Note that this allows the model to (not) use a baseload process in a season, and
+only applies over the :code:`time_of_day` set.
+
+Ideally, this constraint would not be necessary, and baseload processes would
+simply not have a :math:`d` index. However, implementing the more efficient
+functionality is currently on the Temoa TODO list.
+
+.. math::
+ :label: BaseloadDaily
+
+ SEG_{s, D_0}
+ \cdot \textbf{ACT}_{p, s, d, t, v}
+ =
+ SEG_{s, d}
+ \cdot \textbf{ACT}_{p, s, D_0, t, v}
+
+ \\
+ \forall \{p, s, d, t, v\} \in \Theta_{\text{baseload}}
+"""
+ # Question: How to set the different times of day equal to each other?
+
+ # Step 1: Acquire a "canonical" representation of the times of day
+ l_times = sorted( M.time_of_day ) # i.e. a sorted Python list.
+ # This is the commonality between invocations of this method.
+
+ index = l_times.index( d )
+ if 0 == index:
+ # When index is 0, it means that we've reached the beginning of the array
+ # For the algorithm, this is a terminating condition: do not create
+ # an effectively useless constraint
+ return Constraint.Skip
+
+ # Step 2: Set the rest of the times of day equal in output to the first.
+ # i.e. create a set of constraints that look something like:
+ # tod[ 2 ] == tod[ 1 ]
+ # tod[ 3 ] == tod[ 1 ]
+ # tod[ 4 ] == tod[ 1 ]
+ # and so on ...
+ d_0 = l_times[ 0 ]
+
+ # Step 3: the actual expression. For baseload, must compute the /average/
+ # activity over the segment. By definition, average is
+ # (segment activity) / (segment length)
+ # So: (ActA / SegA) == (ActB / SegB)
+ # computationally, however, multiplication is cheaper than division, so:
+ # (ActA * SegB) == (ActB * SegA)
+ expr = (
+ M.V_Activity[p, s, d, t, v] * M.SegFrac[s, d_0]
+ ==
+ M.V_Activity[p, s, d_0, t, v] * M.SegFrac[s, d]
+ )
+ return expr
+
+
+def EmissionLimit_Constraint ( M, p, e ):
+ r"""
+
+A modeler can track emissions through use of the :code:`commodity_emissions`
+set and :code:`EmissionActivity` parameter. The :math:`EAC` parameter is
+analogous to the efficiency table, tying emissions to a unit of activity. The
+EmissionLimit constraint allows the modeler to assign an upper bound per period
+to each emission commodity.
+
+.. math::
+ :label: EmissionLimit
+
+ \sum_{I,T,V,O|{e,i,t,v,o} \in EAC_{ind}} \left (
+ EAC_{e, i, t, v, o} \cdot \textbf{FO}_{p, s, d, i, t, v, o}
+ \right )
+ \le
+ ELM_{p, e}
+
+ \\
+ \forall \{p, e\} \in ELM_{ind}
+"""
+ emission_limit = M.EmissionLimit[p, e]
+
+ actual_emissions = sum(
+ M.V_FlowOut[p, S_s, S_d, S_i, S_t, S_v, S_o]
+ * M.EmissionActivity[e, S_i, S_t, S_v, S_o]
+
+ for tmp_e, S_i, S_t, S_v, S_o in M.EmissionActivity.sparse_iterkeys()
+ if tmp_e == e
+ if M.ValidActivity( p, S_t, S_v )
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ )
+
+ if int is type( actual_emissions ):
+ msg = ("Warning: No technology produces emission '%s', though limit was "
+ 'specified as %s.\n')
+ SE.write( msg % (e, emission_limit) )
+ return Constraint.Skip
+
+ expr = (actual_emissions <= emission_limit)
+ return expr
+
+
+def MinCapacity_Constraint ( M, p, t ):
+ r""" See MaxCapacity_Constraint """
+
+ min_cap = value( M.MinCapacity[p, t] )
+ expr = (M.V_CapacityAvailableByPeriodAndTech[p, t] >= min_cap)
+ return expr
+
+
+def MaxCapacity_Constraint ( M, p, t ):
+ r"""
+
+The MinCapacity and MaxCapacity constraints set limits on the what the model is
+allowed to (not) have available of a certain technology. Note that the indices
+for these constraints are period and tech_all, not tech and vintage.
+
+.. math::
+ :label: MinCapacityCapacityAvailableByPeriodAndTech
+
+ \textbf{CAPAVL}_{p, t} \ge MIN_{p, t}
+
+ \forall \{p, t\} \in \Theta_{\text{MinCapacity parameter}}
+
+.. math::
+ :label: MaxCapacity
+
+ \textbf{CAPAVL}_{p, t} \le MAX_{p, t}
+
+ \forall \{p, t\} \in \Theta_{\text{MaxCapacity parameter}}
+"""
+ max_cap = value( M.MaxCapacity[p, t] )
+ expr = (M.V_CapacityAvailableByPeriodAndTech[p, t] <= max_cap)
+ return expr
+
+def MinCapacitySet_Constraint ( M, p ):
+ r""" See MinCapacity_Constraint """
+ min_cap = value( M.MinCapacitySum[p] )
+ aggcap = sum ( M.V_CapacityAvailableByPeriodAndTech[p, t]
+ for t in M.tech_capacity_min
+ )
+ expr = (aggcap >= min_cap)
+ return expr
+
+def MaxCapacitySet_Constraint ( M, p ):
+ r""" See MaxCapacity_Constraint """
+ max_cap = value( M.MaxCapacitySum[p] )
+ aggcap = sum ( M.V_CapacityAvailableByPeriodAndTech[p, t]
+ for t in M.tech_capacity_max
+ )
+ expr = (aggcap <= max_cap)
+ return expr
+
+def MaxActivity_Constraint ( M, p, t ):
+ r"""
+
+The MaxActivity sets an upper bound on the activity from a specific technology. Note that the indices
+for these constraints are period and tech_all, not tech and vintage.
+
+"""
+
+ activity_pt = sum( M.V_Activity[p, S_s, S_d, t, S_v]
+
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ for S_v in M.ProcessVintages( p, t )
+ )
+ max_act = value( M.MaxActivity[p, t] )
+ expr = (activity_pt <= max_act)
+ return expr
+
+def MinActivity_Constraint ( M, p, t ):
+ r"""
+
+The MinActivity sets a lower bound on the activity from a specific technology. Note that the indices
+for these constraints are period and tech_all, not tech and vintage.
+
+"""
+
+ activity_pt = sum( M.V_Activity[p, S_s, S_d, t, S_v]
+
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ for S_v in M.ProcessVintages( p, t )
+ )
+ min_act = value( M.MinActivity[p, t] )
+ expr = (activity_pt >= min_act)
+ return expr
+
+def MinActivityGroup_Constraint ( M, p , g ):
+
+
+ g_techs=set()
+ for i in M.GroupOfTechnologies.value:
+ if i[1]==g:
+ g_techs.add(i[0])
+ activity_p = sum( M.V_Activity[p, S_s, S_d, t, S_v]
+
+ for t in g_techs
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ for S_v in M.ProcessVintages( p, t )
+ )
+ min_act = value( M.MinGenGroupOfTechnologies_Data[p,g] )
+ expr = (activity_p >= min_act)
+ return expr
+
+
+def Storage_Constraint ( M, p, s, i, t, v, o ):
+ r"""
+
+Temoa's algorithm for storage is to ensure that the amount of energy entering
+and leaving a storage technology is balanced over the course of a day,
+accounting for the conversion efficiency of the storage process. This
+
+constraint relies on the assumption that the total amount of storage-related
+energy is small compared to the amount of energy required by the system over a
+season. If it were not, the algorithm would have to account for
+season-to-season transitions, which would require an ordering of seasons within
+the model. Currently, each slice is completely independent of other slices.
+
+.. math::
+ :label: Storage
+
+ \sum_{D} \left (
+ EFF_{i, t, v, o}
+ \cdot \textbf{FI}_{p, s, d, i, t, v, o}
+ - \textbf{FO}_{p, s, d, i, t, v, o}
+ \right )
+ = 0
+
+ \forall \{p, s, i, t, v, o\} \in \Theta_{\text{storage}}
+"""
+ total_out_in = sum(
+ M.Efficiency[i, t, v, o]
+ * M.V_FlowIn[p, s, S_d, i, t, v, o]
+ - M.V_FlowOut[p, s, S_d, i, t, v, o]
+
+ for S_d in M.time_of_day
+ )
+
+ expr = ( total_out_in == 0 )
+ return expr
+
+def HourlyStorage_Constraint ( M, p, s, d, t ):
+
+ InitialStorage = 0 #batteries are assumed delivered uncharged
+
+ #this is the sum of all input=i sent TO storage tech t of vintage v with output=o in P,S,D, (in PJ)
+ charge = sum( M.V_FlowIn[p, s, d, S_i, t, S_v, S_o] * M.Efficiency[S_i, t, S_v, S_o]
+ for S_v in M.ProcessVintages( p, t )
+ for S_i in M.ProcessInputs( p, t, S_v )
+ for S_o in M.ProcessOutputsByInput( p, t, S_v, S_i )
+ ) * value( M.SegFrac[s,d] )
+
+ #this is the sum of all output=o withdrawn FROM storage tech t of vintage v with input=i P,S,D, (in PJ)
+ discharge = sum( M.V_FlowOut[p, s, d, S_i, t, S_v, S_o]
+ for S_v in M.ProcessVintages( p, t )
+ for S_o in M.ProcessOutputs( p, t, S_v )
+ for S_i in M.ProcessInputsByOutput( p, t, S_v, S_o )
+ ) * value( M.SegFrac[s,d] )
+
+ stored_energy = charge - discharge
+
+# this hourly storage formulation allows stored energy to carry over through time of day and seasons, but must be zeroed out at the end of each period
+
+ if d == M.time_of_day.last() and s == M.time_season.last(): #last time slice of the last season (aka end of period), must zero out
+ d_prev = M.time_of_day.prev(d)
+ expr = ( M.V_HourlyStorage[p, s, d_prev, t] + stored_energy == 0 )
+
+ elif d == M.time_of_day.first() and s == M.time_season.first(): #first time slice of the first season (aka start of period), starts at zero
+ expr = ( M.V_HourlyStorage[p,s,d,t] == stored_energy )
+
+ elif d == M.time_of_day.first(): #first time slice of any season that is NOT the first season
+ d_last = M.time_of_day.last()
+ s_prev = M.time_season.prev(s)
+ expr = ( M.V_HourlyStorage[p,s,d,t] == M.V_HourlyStorage[p,s_prev,d_last,t] + stored_energy )
+
+ else: #so this is any time slice that is NOT covered above (so not the period end time slice; not the period beginning time slice; and not the first time slice of any season)
+ d_prev = M.time_of_day.prev(d)
+ expr = ( M.V_HourlyStorage[p,s,d,t] == M.V_HourlyStorage[p,s,d_prev,t] + stored_energy )
+
+ return expr
+
+def HourlyStorage_UpperBound ( M, p, s, d, t ):
+ # V_HourlyStorage is in terms of PJ; so in any single time slice, amount of cumulative stored energy cannot exceed capacity (GW) * 8 (hours) = GWh
+ # need to convert GWh capacity to PJ (3600/10^6)
+
+ energy_capacity = M.V_CapacityAvailableByPeriodAndTech[p,t] * 8 * 3600 / 10**6
+
+# energy_capacity = M.V_CapacityAvailableByPeriodAndTech[p,t] * value( M.CapacityToActivity[t] ) * value( M.SegFrac[s,d] ) * 8
+
+ expr = ( M.V_HourlyStorage[p,s,d,t] <= energy_capacity )
+
+ return expr
+
+def HourlyStorage_LowerBound ( M, p, s, d, t ):
+ # V_HourlyStorage is in terms of PJ; so in any single time slice, amount of cumulative stored energy cannot dip below some minimum value (zero)
+ # need to convert GWh capacity to PJ (3600/10^6)
+
+ expr = (M.V_HourlyStorage[p,s,d,t] >= 0) #no minimum charge, can achieve 100% DOD
+
+ return expr
+
+def HourlyStorageCharge_UpperBound ( M, p, s, d, t ):
+ # This must limit the rate that energy (PJ) can flow into the battery - limited by the battery size (capacity in GW)
+ # The battery capacity is defined by GW (GJ/s). Convert GJ/s to PJ/h, and this is the maximum that can flow into the battery in 1 hour
+
+# hourly_charge = sum( M.V_FlowIn[p, s, d, S_i, t, S_v, S_o] * M.Efficiency[S_i, t, S_v, S_o]
+# for S_v in ProcessVintages( p, t )
+# for S_i in ProcessInputs( p, t, S_v )
+# for S_o in ProcessOutputsByInput( p, t, S_v, S_i )
+# )
+#
+# max_charge = M.V_CapacityAvailableByPeriodAndTech[p,t] * 3600/10**6 #converts GWh to PJ, treats each time slice as 1 hour
+
+
+ hourly_charge = sum( M.V_FlowIn[p, s, d, S_i, t, S_v, S_o] * M.Efficiency[S_i, t, S_v, S_o]
+ for S_v in M.ProcessVintages( p, t )
+ for S_i in M.ProcessInputs( p, t, S_v )
+ for S_o in M.ProcessOutputsByInput( p, t, S_v, S_i )
+ ) * value( M.SegFrac[s,d] )
+
+ max_charge = M.V_CapacityAvailableByPeriodAndTech[p,t] * 3600/10**6 #converts GWh to PJ, treats each time slice as 92 hours
+
+ expr = ( hourly_charge <= max_charge ) #energy charge rate cannot exceed the capacity of the battery (in GW)
+
+ return expr
+
+def HourlyStorageCharge_LowerBound ( M, p, s, d, t ):
+ # This must limit the rate that energy (PJ) can flow out of the battery - limited by the battery size (capacity in GW)
+ # The battery capacity is defined by GW (GJ/s). Convert GJ/s to PJ/h, and this is the maximum that can flow out of the battery in 1 hour
+
+ hourly_discharge = sum( M.V_FlowOut[p, s, d, S_i, t, S_v, S_o]
+ for S_v in M.ProcessVintages( p, t )
+ for S_o in M.ProcessOutputs( p, t, S_v )
+ for S_i in M.ProcessInputsByOutput( p, t, S_v, S_o )
+ ) * value( M.SegFrac[s,d] )
+
+ max_discharge = M.V_CapacityAvailableByPeriodAndTech[p,t] * 3600/10**6 #converts GWh to PJ, treats each time slice as 1 hour
+
+# hourly_discharge = sum( M.V_FlowOut[p, s, d, S_i, t, S_v, S_o]
+# for S_v in ProcessVintages( p, t )
+# for S_o in ProcessOutputs( p, t, S_v )
+# for S_i in ProcessInputsByOutput( p, t, S_v, S_o )
+# )
+
+# max_discharge = M.V_CapacityAvailableByPeriodAndTech[p,t] * (value( M.CapacityToActivity[t] ) * value( M.SegFrac[s,d] )) #converts GWh to PJ, treats each time slice as 92 hours
+
+ expr = ( hourly_discharge <= max_discharge ) #energy discharge rate cannot exceed the capacity of the battery (in GW)
+
+ return expr
+
+def TechInputSplit_Constraint ( M, p, s, i, t, v ):
+ r"""
+
+Allows users to specify fixed or minimum shares of commodity inputs to a process
+producing a single output. These shares can vary by model time period. See
+TechOutputSplit_Constraint for an analogous explanation.
+"""
+ inp = sum( M.V_FlowIn[p, s, d, i, t, v, S_o]
+ for S_o in M.ProcessOutputsByInput( p, t, v, i )
+ for d in M.time_of_day
+
+ )
+
+ total_inp = sum( M.V_FlowIn[p, s, d, S_i, t, v, S_o]
+ for S_i in M.ProcessInputs( p, t, v )
+ for S_o in M.ProcessOutputsByInput( p, t, v, i )
+ for d in M.time_of_day
+ )
+
+ expr = ( inp >= M.TechInputSplit[p, i, t] * total_inp )
+ return expr
+
+
+def TechOutputSplit_Constraint ( M, p, s, d, t, v, o ):
+ r"""
+
+Some processes take a single input and make multiple outputs, and the user would like to
+specify either a constant or time-varying ratio of outputs per unit input. The most
+canonical example is an oil refinery. Crude oil is used to produce many different refined
+products. In many cases, the modeler would like to specify a minimum share of each refined
+product produced by the refinery.
+
+For example, a hypothetical (and highly simplified) refinery might have a crude oil input
+that produces 4 parts diesel, 3 parts gasoline, and 2 parts kerosene. The relative
+ratios to the output then are:
+
+.. math::
+
+ d = \tfrac{4}{9} \cdot \text{total output}, \qquad
+ g = \tfrac{3}{9} \cdot \text{total output}, \qquad
+ k = \tfrac{2}{9} \cdot \text{total output}
+
+Note that it is possible to specify output shares that sum to less than unity. In such
+cases, the model optimizes the remaining share. In addition, it is possible to change the
+specified shares by model time period. The constraint is formulated as follows:
+
+.. math::
+ :label: TechOutputSplit
+
+ \sum_{I} \textbf{FO}_{p, s, d, i, t, v, o}
+ \geq
+ SPL_{p, t, o} \cdot \textbf{ACT}_{p, s, d, t, v}
+
+ \forall \{p, s, d, t, v, o\} \in \Theta_{\text{split output}}
+"""
+ out = sum( M.V_FlowOut[p, s, d, S_i, t, v, o]
+ for S_i in M.ProcessInputsByOutput( p, t, v, o ) )
+
+ expr = ( out >= M.TechOutputSplit[p, t, o] * M.V_Activity[p, s, d, t, v] )
+ return expr
+
+
+def Activity_Constraint ( M, p, s, d, t, v ):
+ r"""
+The Activity constraint defines the Activity convenience variable. The Activity
+variable is mainly used in the objective function to calculate the cost
+associated with use of a technology. In English, this constraint states that
+"the activity of a process is the sum of its outputs."
+
+There is one caveat to keep in mind in regards to the Activity variable: if
+there is more than one output, there is currently no attempt by Temoa to convert
+to a common unit of measurement. For example, common measurements for heat
+include mass of steam at a given temperature, or total BTUs, while electricity
+is generally measured in a variant of watt-hours. Reconciling these units of
+measurement, as for example with a cogeneration plant, is currently left as an
+accounting exercise for the modeler.
+
+.. math::
+ :label: Activity
+
+ \textbf{ACT}_{p, s, d, t, v} = \sum_{I, O} \textbf{FO}_{p,s,d,i,t,v,o}
+
+ \\
+ \forall \{p, s, d, t, v\} \in \Theta_{\text{activity}}
+"""
+ activity = sum(
+ M.V_FlowOut[p, s, d, S_i, t, v, S_o]
+
+ for S_i in M.ProcessInputs( p, t, v )
+ for S_o in M.ProcessOutputsByInput( p, t, v, S_i )
+ )
+
+ expr = ( M.V_Activity[p, s, d, t, v] == activity )
+ return expr
+
+
+def Capacity_Constraint ( M, p, s, d, t, v ):
+ r"""
+
+Temoa's definition of a process' capacity is the total size of installation
+required to meet all of that process' demands. The Activity convenience
+variable represents exactly that, so the calculation on the left hand side of
+the inequality is the maximum amount of energy a process can produce in the time
+slice ````.
+
+.. math::
+ :label: Capacity
+
+ \left (
+ \text{CFP}_{t, v}
+ \cdot \text{C2A}_{t}
+ \cdot \text{SEG}_{s, d}
+ \cdot \text{TLF}_{p, t, v}
+ \right )
+ \cdot \textbf{CAP}_{t, v}
+ \ge
+ \textbf{ACT}_{p, s, d, t, v}
+
+ \\
+ \forall \{p, s, d, t, v\} \in \Theta_{\text{activity}}
+"""
+
+ if t in M.tech_hourlystorage:
+ return Constraint.Skip
+
+ produceable = (
+ ( value( M.CapacityFactorProcess[s, d, t, v] )
+ * value( M.CapacityToActivity[ t ] )
+ * value( M.SegFrac[s, d]) )
+ * value( M.ProcessLifeFrac[p, t, v] )
+ * M.V_Capacity[t, v]
+ * value( M.CapReduction[p,t,v])) #JB - added v
+
+ expr = (produceable >= M.V_Activity[p, s, d, t, v])
+ return expr
+
+#sudan
+def availableActivity_Constraint ( M, p, t ,v):
+ #This is max produceable in a given year by a perticular technology
+ max_produceable = sum((
+ ( value( M.CapacityFactorProcess[S_s, S_d, t, S_v] )
+ * value( M.CapacityToActivity[ t ] )
+ * value( M.SegFrac[S_s, S_d]) )
+ * value( M.ProcessLifeFrac[p, t, S_v] )
+ * M.V_Capacity[t, S_v]
+ * value( M.CapReduction[p,t,S_v])) # JB - added 'S_v
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ for S_v in M.ProcessVintages(p,t))
+
+ #This is what is produced in a year by a particular technology
+ activity_pt = sum( M.V_Activity[p, S_s, S_d, t, S_v]
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ for S_v in M.ProcessVintages(p,t))
+
+ #If not then we have to deduct the produceable from the capacity built in the current year
+ if t in M.delay:
+ #Produceable from capacity built in the current year
+ most_recent = sum(( value( M.CapacityFactorProcess[S_s, S_d, t, S_v] )
+ * value( M.CapacityToActivity[ t ] )
+ * value( M.SegFrac[S_s, S_d]) )
+ * value( M.ProcessLifeFrac[p, t, S_v] )
+ * M.V_Capacity[t, S_v]
+ * value( M.CapReduction[p,t,S_v]) #JB - added S_v
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ for S_v in M.ProcessVintages(p,t)
+ if S_v == p)
+ max_produceable_delay=max_produceable - most_recent;
+ expr = (activity_pt <=max_produceable_delay)
+ return expr
+ #If the technology has existing capacity then all good - then this constraint is same as previous constraint
+ else:
+ expr = (activity_pt <= max_produceable)
+ return expr
+
+def ExistingCapacity_Constraint ( M, t, v ):
+ r"""
+
+Temoa treats residual capacity from before the model's optimization horizon as
+regular processes, that require the same parameter specification in the data
+file as do new vintage technologies (e.g. entries in the efficiency table),
+except the :code:`CostInvest` parameter. This constraint sets the capacity of
+processes for model periods that exist prior to the optimization horizon to
+user-specified values.
+
+.. math::
+ :label: ExistingCapacity
+
+ \textbf{CAP}_{t, v} = ECAP_{t, v}
+
+ \forall \{t, v\} \in \Theta_{\text{existing}}
+"""
+ expr = ( M.V_Capacity[t, v] == M.ExistingCapacity[t, v] )
+ return expr
+
+
+def ResourceExtraction_Constraint ( M, p, r ):
+ r"""
+
+The ResourceExtraction constraint allows a modeler to specify an annual limit on
+the amount of a particular resource Temoa may use in a period.
+
+.. math::
+ :label: ResourceExtraction
+
+ \sum_{S, D, I, t \in T^r, V} \textbf{FO}_{p, s, d, i, t, v, c} \le RSC_{p, c}
+
+ \forall \{p, c\} \in \Theta_{\text{resource bound parameter}}
+"""
+ collected = sum(
+ M.V_FlowOut[p, S_s, S_d, S_i, S_t, S_v, r]
+
+ for S_t, S_v in M.ProcessesByPeriodAndOutput( p, r )
+ if S_t in M.tech_resource
+ for S_i in M.ProcessInputsByOutput( p, S_t, S_v, r )
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ )
+
+ expr = (collected <= M.ResourceBound[p, r])
+ return expr
+
+
+def CommodityBalance_Constraint ( M, p, s, d, c ):
+ r"""
+
+Where the Demand constraint :eq:`Demand` ensures that end-use demands are met,
+the CommodityBalance constraint ensures that the internal system demands are
+met. That is, this is the constraint that ties the output of one process to the
+input of another. At the same time, this constraint also conserves energy
+between process. (But it does not account for transmission loss.) In this
+manner, it is a corollary to both the ProcessBalance :eq:`ProcessBalance` and
+Demand :eq:`Demand` constraints.
+
+.. math::
+ :label: CommodityBalance
+
+ \sum_{I, T, V} \textbf{FO}_{p, s, d, i, t, v, c}
+ =
+ \sum_{T, V, O} \textbf{FI}_{p, s, d, c, t, v, o}
+
+ \\
+ \forall \{p, s, d, c\} \in \Theta_{\text{commodity balance}}
+"""
+ if c in M.commodity_demand:
+ return Constraint.Skip
+
+ vflow_in = sum(
+ M.V_FlowIn[p, s, d, c, S_t, S_v, S_o]
+
+ for S_t, S_v in M.helper_commodityDStreamProcess[p, c]
+ for S_o in M.helper_ProcessOutputsByInput[ p, S_t, S_v, c ]
+ )
+
+ vflow_out = sum(
+ M.V_FlowOut[p, s, d, S_i, S_t, S_v, c]
+
+ for S_t, S_v in M.helper_commodityUStreamProcess[p, c]
+ for S_i in M.helper_ProcessInputsByOutput[ (p, S_t, S_v, c) ]
+ )
+
+ CommodityBalanceConstraintErrorCheck( vflow_out, vflow_in, p, s, d, c )
+
+ expr = (vflow_out == vflow_in)
+ return expr
+
+
+def ProcessBalance_Constraint ( M, p, s, d, i, t, v, o ):
+ r"""
+
+The ProcessBalance constraint is one of the most fundamental constraints in the
+Temoa model. It defines the basic relationship between the energy entering a
+process (:math:`\textbf{FI}`) and the energy leaving a processing
+(:math:`\textbf{FO}`). This constraint sets the :code:`FlowOut` variable, upon
+which all other constraints rely.
+
+Conceptually, this constraint treats every process as a "black box," caring only
+about the process efficiency. In other words, the amount of energy leaving a
+process cannot exceed the amount coming in.
+
+Note that this constraint is an inequality -- not a strict equality. In most
+sane cases, the optimal solution should make this constraint and supply should
+exactly meet demand. If this constraint is not binding, it is likely a clue
+that the model under inspection could be more tightly specified and has at least
+one input data anomaly.
+
+.. math::
+ :label: ProcessBalance
+
+ \textbf{FO}_{p, s, d, i, t, v, o}
+ \le
+ EFF_{i, t, v, o}
+ \cdot \textbf{FI}_{p, s, d, i, t, v, o}
+
+ \\
+ \forall \{p, s, d, i, t, v, o\} \in \Theta_{\text{valid process flows}}
+"""
+ expr = (
+ M.V_FlowOut[p, s, d, i, t, v, o]
+ ==
+ M.V_FlowIn[p, s, d, i, t, v, o]
+ * value( M.Efficiency[i, t, v, o] )
+ )
+
+ return expr
+
+
+def DemandActivity_Constraint ( M, p, s, d, t, v, dem, s_0, d_0 ):
+ r"""
+
+For end-use demands, it is unreasonable to let the optimizer only allow use in a
+single time slice. For instance, if household A buys a natural gas furnace
+while household B buys an electric furnace, then both units should be used
+throughout the year. Without this constraint, the model might choose to only
+use the electric furnace during the day, and the natural gas furnace during the
+night.
+
+This constraint ensures that the ratio of a process activity to demand is
+constant for all time slices. Note that if a demand is not specified in a given
+time slice, or is zero, then this constraint will not be considered for that
+slice and demand. This is transparently handled by the :math:`\Theta` superset.
+
+.. math::
+ :label: DemandActivity
+
+ DEM_{p, s, d, dem} \cdot \sum_{I} \textbf{FO}_{p, s_0, d_0, i, t, v, dem}
+ =
+ DEM_{p, s_0, d_0, dem} \cdot \sum_{I} \textbf{FO}_{p, s, d, i, t, v, dem}
+
+ \\
+ \forall \{p, s, d, t, v, dem, s_0, d_0\} \in \Theta_{\text{demand activity}}
+"""
+
+ DSD = M.DemandSpecificDistribution # lazy programmer
+ act_a = sum(
+ M.V_FlowOut[p, s_0, d_0, S_i, t, v, dem]
+
+ for S_i in M.ProcessInputsByOutput( p, t, v, dem )
+ )
+ act_b = sum(
+ M.V_FlowOut[p, s, d, S_i, t, v, dem]
+
+ for S_i in M.ProcessInputsByOutput( p, t, v, dem )
+ )
+
+ expr = (
+ act_a * DSD[s, d, dem]
+ ==
+ act_b * DSD[s_0, d_0, dem]
+ )
+ return expr
+
+
+def Demand_Constraint ( M, p, s, d, dem ):
+ r"""
+
+The Demand constraint drives the model. This constraint ensures that supply at
+least meets the demand specified by the Demand parameter in all periods and
+slices, by ensuring that the sum of all the demand output commodity (:math:`c`)
+generated by :math:`\textbf{FO}` must meet the modeler-specified demand, in
+each time slice.
+
+.. math::
+ :label: Demand
+
+ \sum_{I, T, V} \textbf{FO}_{p, s, d, i, t, v, dem}
+ \ge
+ {DEM}_{p, dem} \cdot {DSD}_{s, d, dem}
+
+ \\
+ \forall \{p, s, d, dem\} \in \Theta_{\text{demand}}
+
+Note that the validity of this constraint relies on the fact that the
+:math:`C^d` set is distinct from both :math:`C^e` and :math:`C^p`. In other
+words, an end-use demand must only be an end-use demand. Note that if an output
+could satisfy both an end-use and internal system demand, then the output from
+:math:`\textbf{FO}` would be double counted.
+
+Note also that this constraint is an inequality, not a strict equality. "Supply
+must meet or exceed demand." Like with the ProcessBalance constraint, if this
+constraint is not binding, it may be a clue that the model under inspection
+could be more tightly specified and could have at least one input data anomaly.
+
+"""
+ supply = sum(
+ M.V_FlowOut[p, s, d, S_i, S_t, S_v, dem]
+
+ for S_t, S_v in M.helper_commodityUStreamProcess[ p, dem ]
+ for S_i in M.helper_ProcessInputsByOutput[ p, S_t, S_v, dem ]
+ )
+
+ DemandConstraintErrorCheck( supply, p, s, d, dem )
+
+ expr = (supply >= M.Demand[p, dem] * M.DemandSpecificDistribution[s, d, dem])
+
+ return expr
+
+
+def GrowthRateConstraint_rule ( M, p, t ):
+ GRS = value( M.GrowthRateSeed[ t ] )
+ GRM = value( M.GrowthRateMax[ t ] )
+ CapPT = M.V_CapacityAvailableByPeriodAndTech
+
+ periods = sorted(set(p_ for p_, t_ in CapPT if t_ == t) )
+
+ if p not in periods:
+ return Constraint.Skip
+
+ if p == periods[0]:
+ expr = ( CapPT[p, t] <= GRS )
+
+ else:
+ p_prev = periods.index( p )
+ p_prev = periods[ p_prev -1]
+
+ expr = ( CapPT[p, t] <= GRM * CapPT[p_prev, t] + GRS )
+
+ return expr
+
+
+##############################################################################
+# Additional and derived (informational) variable constraints
+
+
+def ActivityByPeriodAndProcess_Constraint ( M, p, t, v ):
+ if p < v or v not in M.ProcessVintages( p, t ):
+ return Constraint.Skip
+
+ activity = sum(
+ M.V_Activity[p, S_s, S_d, t, v]
+
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ )
+
+ if int is type( activity ):
+ return Constraint.Skip
+
+ expr = (M.V_ActivityByPeriodAndProcess[p, t, v] == activity)
+ return expr
+
+#This is required for MGA objective function
+def ActivityByTech_Constraint ( M, t ):
+
+ activity = sum(
+ M.V_Activity[S_p, S_s, S_d, t, S_v]
+
+ for S_p in M.time_optimize
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ for S_v in M.ProcessVintages( S_p, t )
+ )
+
+ if int is type( activity ):
+ return Constraint.Skip
+
+ expr = (M.V_ActivityByTech[t] == activity)
+ return expr
+
+
+def CapacityAvailableByPeriodAndTech_Constraint ( M, p, t ):
+ r"""
+The :math:`\textbf{CAPAVL}` variable is nominally for reporting solution values,
+but is also used in the Max and Min constraint calculations. For any process
+with an end-of-life (EOL) on a period boundary, all of its capacity is available
+for use in all periods in which it is active (the process' TLF is 1). However,
+for any process with an EOL that falls between periods, Temoa makes the
+simplifying assumption that the available capacity from the expiring technology
+is available through the whole period, but only as much percentage as its
+lifespan through the period. For example, if a process expires 3 years into an
+8 year period, then only :math:`\frac{3}{8}` of the installed capacity is
+available for use throughout the period.
+
+.. math::
+ :label: CapacityAvailable
+
+ \textbf{CAPAVL}_{p, t} = \sum_{V} {TLF}_{p, t, v} \cdot \textbf{CAP}
+
+ \\
+ \forall p \in \text{P}^o, t \in T
+"""
+ cap_avail = sum(
+ value( M.ProcessLifeFrac[p, t, S_v] )
+ * M.V_Capacity[t, S_v]
+
+ for S_v in M.ProcessVintages( p, t )
+ )
+
+ expr = (M.V_CapacityAvailableByPeriodAndTech[p, t] == cap_avail)
+ return expr
+
+def EnergyConsumptionByPeriodInputAndTech_Constraint ( M, p, i, t ):
+ energy_used = sum(
+ M.V_FlowIn[p, S_s, S_d, i, t, S_v, S_o]
+
+ for S_v in M.ProcessVintages( p, t )
+ for S_o in M.ProcessOutputsByInput( p, t, S_v, i )
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ )
+
+ expr = (M.V_EnergyConsumptionByPeriodInputAndTech[p, i, t] == energy_used)
+ return expr
+
+def ActivityByPeriodTechAndOutput_Constraint ( M, p, t, o ):
+ activity = sum(
+ M.V_FlowOut[p, S_s, S_d, S_i, t, S_v, o]
+
+ for S_v in M.ProcessVintages( p, t )
+ for S_i in M.ProcessInputsByOutput( p, t, S_v, o )
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ )
+
+ if int is type( activity ):
+ return Constraint.Skip
+
+ expr = (M.V_ActivityByPeriodTechAndOutput[p, t, o] == activity)
+ return expr
+
+def EmissionActivityByPeriodAndTech_Constraint ( M, e, p, t ):
+ emission_total = sum(
+ M.V_FlowOut[p, S_s, S_d, S_i, t, S_v, S_o]
+ * M.EmissionActivity[e, S_i, t, S_v, S_o]
+
+ for tmp_e, S_i, S_t, S_v, S_o in M.EmissionActivity.sparse_iterkeys()
+ if tmp_e == e and S_t == t
+ if M.ValidActivity( p, S_t, S_v )
+ for S_s in M.time_season
+ for S_d in M.time_of_day
+ )
+
+ if type( emission_total ) is int:
+ return Constraint.Skip
+
+ expr = (M.V_EmissionActivityByPeriodAndTech[e, p, t] == emission_total)
+ return expr
+
+def RampUpDay_Constraint ( M, p, s, d, t, v):
+# M.time_of_day is a sorted set, and M.time_of_day.first() returns the first
+# element in the set, similarly, M.time_of_day.last() returns the last element.
+# M.time_of_day.prev(d) function will return the previous element before s, and
+# M.time_of_day.next(d) function will return the next element after s.
+
+ r"""
+The ramp rate constraint is utilized to limit the rate of electricity generation
+increase and decrease between two adjacent time slices in order to account for
+physical limits associated with thermal power plants. Note that this constriant
+only applies to technologies with ramp capability, which is defined in set
+:math:`\textbf{T}^{ramp}`. We assume for simplicity the rate limits for both
+ramp up and down are equal and they do not vary with technology vintage. The
+ramp rate limits (:math:`r_t`) for technology :math:`t` should be expressed in
+percentage of its rated capacity.
+
+Note that when :math:`d_{nd}` is the last time-of-day, :math:`d_{nd + 1} \not \in
+\textbf{D}`, i.e., if one time slice is the last time-of-day in a season and the
+other time slice is the first time-of-day in the next season, the ramp rate
+limits between these two time slices can not be expressed by :eq:`ramp_up_day`.
+Therefore, the ramp rate constraints between two adjacent seasons are
+represented in :eq:`ramp_up_season`.
+
+In Equation :eq:`ramp_up_day` and :eq:`ramp_up_season`, we assume
+:math:`\textbf{S} = \{s_i, i = 1, 2, \cdots, ns\}` and
+:math:`\textbf{D} = \{d_i, i=1, 2, \cdots, nd\}`.
+
+.. math::
+ \frac{
+ \textbf{ACT}_{p, s, d_{i + 1}, t, v}
+ }{
+ SEG_{s, d_{i + 1}} \cdot C2A_t
+ }
+ -
+ \frac{
+ \textbf{ACT}_{p, s, d_i, t, v}
+ }{
+ SEG_{s, d_i} \cdot C2A_t
+ }
+ \leq
+ r_t \cdot \textbf{CAPAVL}_{p,t}
+ \\
+ \forall
+ p \in \textbf{P}^o,
+ s \in \textbf{S},
+ d_i, d_{i + 1} \in \textbf{D},
+ t \in \textbf{T}^{ramp},
+ v \in \textbf{V}
+ :label: ramp_up_day
+"""
+ if d != M.time_of_day.first():
+ d_prev = M.time_of_day.prev(d)
+ expr_left = (
+ M.V_Activity[ p, s, d, t, v ]/value( M.SegFrac[s, d] ) -
+ M.V_Activity[ p, s, d_prev, t, v ]/value( M.SegFrac[s, d_prev] )
+ )/value( M.CapacityToActivity[ t ] )
+ expr_right = M.V_Capacity[t, v]*value( M.RampUp[t] )
+ expr = (expr_left <= expr_right)
+ else:
+ return Constraint.Skip
+
+ return expr
+
+def RampUpSeason_Constraint ( M, p, s, t, v):
+ r"""
+Note that :math:`d_1` and :math:`d_{nd}` represent the first and last time-of-day,
+respectively.
+
+.. math::
+ \frac{
+ \textbf{ACT}_{p, s_{i + 1}, d_1, t, v}
+ }{
+ SEG_{s_{i + 1}, d_1} \cdot C2A_t
+ }
+ -
+ \frac{
+ \textbf{ACT}_{p, s_i, d_{nd}, t, v}
+ }{
+ SEG_{s_i, d_{nd}} \cdot C2A_t
+ }
+ \leq
+ r_t \cdot \textbf{CAPAVL}_{p,t}
+ \\
+ \forall
+ p \in \textbf{P}^o,
+ s_i, s_{i + 1} \in \textbf{S},
+ d_1, d_{nd} \in \textbf{D},
+ t \in \textbf{T}^{ramp},
+ v \in \textbf{V}
+ :label: ramp_up_season
+"""
+ if s != M.time_season.first():
+ s_prev = M.time_season.prev(s)
+ d_first = M.time_of_day.first()
+ d_last = M.time_of_day.last()
+ expr_left = (
+ M.V_Activity[ p, s, d_first, t, v ]/M.SegFrac[s, d_first] -
+ M.V_Activity[ p, s_prev, d_last, t, v ]/M.SegFrac[s_prev, d_last]
+ )/value( M.CapacityToActivity[ t ] )
+ expr_right = M.V_Capacity[t, v]*value( M.RampUp[t] )
+ expr = (expr_left <= expr_right)
+ else:
+ return Constraint.Skip
+
+ return expr
+
+def RampUpPeriod_Constraint ( M, p, t, v):
+
+ # if p != M.time_future.first():
+ # p_prev = M.time_future.prev(p)
+ # s_first = M.time_season.first()
+ # s_last = M.time_season.last()
+ # d_first = M.time_of_day.first()
+ # d_last = M.time_of_day.last()
+ # expr_left = (
+ # M.V_Activity[ p, s_first, d_first, t, v ] -
+ # M.V_Activity[ p_prev, s_last, d_last, t, v ]
+ # )
+ # expr_right = (
+ # M.V_Capacity[t, v]*
+ # value( M.RampUp[t] )*
+ # value( M.CapacityToActivity[ t ] )*
+ # value( M.SegFrac[s, d])
+ # )
+ # expr = (expr_left <= expr_right)
+ # else:
+ # return Constraint.Skip
+
+ # return expr
+
+ return Constraint.Skip # We don't need inter-period ramp up/down constraint.
+
+def RampDownDay_Constraint ( M, p, s, d, t, v):
+ r"""
+Similar to Equation :eq:`ramp_up_day` and :eq:`ramp_up_season`, we use Equation
+:eq:`ramp_down_day` and :eq:`ramp_down_season` to limit ramp down rates between
+any two adjacent time slices.
+
+.. math::
+ \frac{
+ \textbf{ACT}_{p, s, d_{i + 1}, t, v}
+ }{
+ SEG_{s, d_{i + 1}} \cdot C2A_t
+ }
+ -
+ \frac{
+ \textbf{ACT}_{p, s, d_i, t, v}
+ }{
+ SEG_{s, d_i} \cdot C2A_t
+ }
+ \geq
+ -r_t \cdot \textbf{CAPAVL}_{p,t}
+ \\
+ \forall
+ p \in \textbf{P}^o,
+ s \in \textbf{S},
+ d_i, d_{i + 1} \in \textbf{D},
+ t \in \textbf{T}^{ramp},
+ v \in \textbf{V}
+ :label: ramp_down_day
+"""
+
+ if d != M.time_of_day.first():
+ d_prev = M.time_of_day.prev(d)
+ expr_left = (
+ M.V_Activity[ p, s, d, t, v ]/value( M.SegFrac[s, d]) -
+ M.V_Activity[ p, s, d_prev, t, v ]/value( M.SegFrac[s, d_prev])
+ )/value( M.CapacityToActivity[ t ] )
+ expr_right = -( M.V_Capacity[t, v]*value( M.RampDown[t] ) )
+ expr = (expr_left >= expr_right)
+ else:
+ return Constraint.Skip
+
+ return expr
+
+def RampDownSeason_Constraint ( M, p, s, t, v):
+ r"""
+.. math::
+ \frac{
+ \textbf{ACT}_{p, s_{i + 1}, d_1, t, v}
+ }{
+ SEG_{s_{i + 1}, d_1} \cdot C2A_t
+ }
+ -
+ \frac{
+ \textbf{ACT}_{p, s_i, d_{nd}, t, v}
+ }{
+ SEG_{s_i, d_{nd}} \cdot C2A_t
+ }
+ \geq
+ -r_t \cdot \textbf{CAPAVL}_{p,t}
+ \\
+ \forall
+ p \in \textbf{P}^o,
+ s_i, s_{i + 1} \in \textbf{S},
+ d_1, d_{nd} \in \textbf{D},
+ t \in \textbf{T}^{ramp},
+ v \in \textbf{V}
+ :label: ramp_down_season
+"""
+ if s != M.time_season.first():
+ s_prev = M.time_season.prev(s)
+ d_first = M.time_of_day.first()
+ d_last = M.time_of_day.last()
+ expr_left = (
+ M.V_Activity[ p, s, d_first, t, v ]/
+ value(
+ M.SegFrac[s, d_first]
+ ) -
+ M.V_Activity[ p, s_prev, d_last, t, v ]/
+ value(
+ M.SegFrac[s_prev, d_last]
+ )
+ )/value( M.CapacityToActivity[ t ] )
+ expr_right = -( M.V_Capacity[t, v]*value( M.RampDown[t] ) )
+ expr = (expr_left >= expr_right)
+ else:
+ return Constraint.Skip
+
+ return expr
+
+def RampDownPeriod_Constraint ( M, p, t, v):
+
+ # if p != M.time_future.first():
+ # p_prev = M.time_future.prev(p)
+ # s_first = M.time_season.first()
+ # s_last = M.time_season.last()
+ # d_first = M.time_of_day.first()
+ # d_last = M.time_of_day.last()
+ # expr_left = (
+ # M.V_Activity[ p, s_first, d_first, t, v ] -
+ # M.V_Activity[ p_prev, s_last, d_last, t, v ]
+ # )
+ # expr_right = (
+ # -1*
+ # M.V_Capacity[t, v]*
+ # value( M.RampDown[t] )*
+ # value( M.CapacityToActivity[ t ] )*
+ # value( M.SegFrac[s, d])
+ # )
+ # expr = (expr_left >= expr_right)
+ # else:
+ # return Constraint.Skip
+
+ # return expr
+
+ return Constraint.Skip # We don't need inter-period ramp up/down constraint.
+
+def ReserveMargin_Constraint( M, p, g, s, d):
+ r"""
+To assure system reliability of power grid, during each period :math:`p`, the
+sum of available capacity of all reserve technologies (defined by set :math:`\textbf{T}^{res}`)
+:math:`\sum_{t \in T^{res}} \textbf{CAPAVL}_{p,t}`, should not exceed the peak
+load plus a reserve margin :math:`RES_c`. Note reserve margin is typically
+expressed in the form of percentage. In Equation :eq:`reserve_margin`, we use
+:math:`(s^*,d^*)` to represent the peak-load time slice.
+
+.. math::
+ \sum_{t \in T^{res}} {
+ CC_t \cdot
+ \textbf{CAPAVL}_{p,t} \cdot
+ SEG_{s^*,d^*} \cdot C2A_t }
+ \geq
+ DEM_{p,c} \cdot
+ DSD_{s^*, d^*, c} \cdot
+ (1 + RES_c)
+ \\
+ \forall
+ p \in \textbf{P}^o,
+ c \in \textbf{C}^{res}
+ :label: reserve_margin
+"""
+ # The season and time-of-day of the slice with the maximum average load.
+ PowerTechs=set() #all the power generation technologies
+ PowerCommodities=set() #it consists of all the commodities coming out of powerplants: ELCP, ELCP_Renewables, ELCP_SOL
+ for i in M.ReserveMargin.sparse_keys():
+ if i[1]==g:
+ PowerCommodities.add(i[0])
+
+ if not PowerCommodities:
+ return Constraint.Skip
+
+ for i,t,v,o in M.Efficiency:
+ if o in PowerCommodities:
+ PowerTechs.add(t)
+
+ expr_left = sum (value( M.CapacityCredit[t] )*
+ M.V_CapacityAvailableByPeriodAndTech[p, t]*
+ value( M.CapacityToActivity[t] )*
+ value( M.SegFrac[s, d] )
+ for t in PowerTechs if (p, t) in M.CapacityAvailableVar_pt ) #M.CapacityAvailableVar_pt check if all the possible consistent combinations of t and p
+
+
+
+ total_generation = sum( M.V_Activity[p, s, d, t, S_v]
+ for t in PowerTechs
+ for S_v in M.ProcessVintages( p, t ))
+
+ expr_right = total_generation*(1 + M.ReserveMargin[PowerCommodities.pop(),g] )
+
+
+ return (expr_left >= expr_right)
+
+
+# End additional and derived (informational) variable constraints
+##############################################################################
+
+# End *_rule definitions
+##############################################################################
+
diff --git a/temoa_stochastic/temoa_model/temoa_run.py b/temoa_stochastic/temoa_model/temoa_run.py
new file mode 100644
index 0000000..493780f
--- /dev/null
+++ b/temoa_stochastic/temoa_model/temoa_run.py
@@ -0,0 +1,533 @@
+"""
+Tools for Energy Model Optimization and Analysis (Temoa):
+An open source framework for energy systems optimization modeling
+
+Copyright (C) 2015, NC State University
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+A complete copy of the GNU General Public License v2 (GPLv2) is available
+in LICENSE.txt. Users uncompressing this from an archive may not have
+received this license file. If not, see " + k + "
"
+ yield k
+ #yield " " * 1024
+ # Now add back the objective function that we earlier removed; note that name
+ # we choose here (FirstObj) will be copied to the output file.
+ temoaInstance1.instance.FirstObj = Objective( rule=TotalCost_rule, sense=minimize )
+ temoaInstance1.instance.preprocess()
+
+ for k in temoaInstance1.solve_temoa_instance():
+ # yield "" + k + "
"
+ yield k
+ #yield " " * 1024
+
+ temoaInstance1.handle_files(log_name='Complete_OutputLog.log' )
+ # using value() converts the now-loaded results into a single number,
+ # which we'll use with our slightly unusual SlackedObjective_rule below
+ # (but defined above).
+ Perfect_Foresight_Obj = value( temoaInstance1.instance.FirstObj )
+
+ # Create a new dictionary that stores the MGA objective function weights
+ prev_activity_t = defaultdict( int )
+ # Store first set of MGA objective weights drawn from base solution
+ prev_activity_t = PreviousAct_rule( temoaInstance1.instance, self.options.mga_weight, prev_activity_t )
+
+ # Perform MGA iterations
+ while self.options.next_mga():
+ temoaMGAInstance = TemoaSolverInstance(self.model, self.optimizer, self.options, self.txt_file)
+ for k in temoaMGAInstance.create_temoa_instance():
+ # yield "" + k + "
"
+ yield k
+ #yield " " * 1024
+
+ try:
+ txt_file_mga = open(self.options.path_to_logs+os.sep+"Complete_OutputLog.log", "w")
+ except BaseException as io_exc:
+ yield "MGA Log file cannot be opened. Please check path. Trying to find:\n"+self.options.path_to_logs+" folder\n"
+ SE.write("MGA Log file cannot be opened. Please check path. Trying to find:\n"+self.options.path_to_logs+" folder\n")
+ txt_file_mga = open("OutputLog_MGA_last.log", "w")
+
+ # Update second instance with the new MGA-specific objective function
+ # and constraint.
+ temoaMGAInstance.instance.SecondObj = Objective(
+ expr=ActivityObj_rule( temoaMGAInstance.instance, prev_activity_t ),
+ noruleinit=True,
+ sense=minimize
+ )
+ temoaMGAInstance.instance.PreviousSlackedObjective = Constraint(
+ rule=None,
+ expr=SlackedObjective_rule( temoaMGAInstance.instance, Perfect_Foresight_Obj, self.options.mga ),
+ noruleinit=True
+ )
+ temoaMGAInstance.instance.preprocess()
+ for k in temoaMGAInstance.solve_temoa_instance():
+ # yield "" + k + "
"
+ yield k
+ #yield " " * 1024
+ temoaMGAInstance.handle_files(log_name='Complete_OutputLog.log' )
+ #Update MGA objective function weights for use in the next iteration
+ prev_activity_t = PreviousAct_rule( temoaMGAInstance.instance, self.options.mga_weight, prev_activity_t )
+
+
+ '''
+ This function is called when MGA option is not specified.
+ '''
+ def solveWithoutMGA(self):
+ temoaInstance1 = TemoaSolverInstance(self.model, self.optimizer, self.options, self.txt_file)
+ for k in temoaInstance1.create_temoa_instance():
+ # yield "" + k + "
"
+ yield k
+ #yield " " * 1024
+ for k in temoaInstance1.solve_temoa_instance():
+ # yield "" + k + "
"
+ yield k
+ #yield " " * 1024
+ temoaInstance1.handle_files(log_name='Complete_OutputLog.log')
+
+ '''
+ This funciton creates and solves TemoaSolverInstance.
+ This is the function that should be called from outside this class after __init__
+ '''
+ def createAndSolve(self):
+ try:
+ self.txt_file = open(self.options.path_to_logs+os.sep+"Complete_OutputLog.log", "w")
+
+ except BaseException as io_exc:
+ yield "Log file cannot be opened. Please check path. Trying to find:\n"+self.options.path_to_logs+" folder\n"
+ SE.write("Log file cannot be opened. Please check path. Trying to find:\n"+self.options.path_to_logs+" folder\n")
+ self.txt_file = open("Complete_OutputLog.log", "w")
+ self.txt_file.write("Log file cannot be opened. Please check path. Trying to find:\n"+self.options.path_to_logs+" folder\n")
+
+ # Check and see if mga attribute exists and if mga is specified
+ try:
+ if hasattr(self.options, 'mga') and self.options.mga:
+ for k in self.solveWithMGA():
+ #yield "" + k + "
"
+ yield k
+ #yield " " * 1024
+ else: # User requested a single run
+ for k in self.solveWithoutMGA():
+ #yield "" + k + "
"
+ yield k
+ #yield " " * 1024
+
+ except KeyboardInterrupt as e:
+ self.txt_file.close()
+ yield str(e) + '\n'
+ yield 'User requested quit. Exiting Temoa ...\n'
+ SE.write(str(e)+'\n')
+ SE.write( 'User requested quit. Exiting Temoa ...\n' )
+ traceback.print_exc()
+ SE.flush()
+ except SystemExit as e:
+ self.txt_file.close()
+ yield str(e) + '\n'
+ yield 'Temoa exit requested. Exiting ...\n'
+ SE.write(str(e)+'\n')
+ SE.write( 'Temoa exit requested. Exiting ...\n' )
+ traceback.print_exc()
+ SE.flush()
+ except Exception as e:
+ self.txt_file.close()
+ yield str(e) + '\n'
+ yield 'Exiting Temoa ...\n'
+ SE.write(str(e)+'\n')
+ SE.write( 'Exiting Temoa ...\n' )
+ traceback.print_exc()
+ SE.flush()
+
+
+
+'''
+This class is for creating one temoa solver instance. It is used by TemoaSolver.
+(Multiple instances are created for MGA/non-MGA options).
+'''
+class TemoaSolverInstance(object):
+ def __init__(self, model, optimizer, options, txt_file):
+ self.model = model
+ self.options = options
+ self.optimizer = optimizer
+ self.txt_file = txt_file
+
+ def create_temoa_instance (self):
+ """Create a single instance of Temoa."""
+
+ try:
+ if self.options.keepPyomoLP:
+ yield '\nSolver will write file: {}\n\n'.format( self.options.scenario + '.lp' )
+ SE.write('\nSolver will write file: {}\n\n'.format( self.options.scenario + '.lp' ))
+ self.txt_file.write('\nSolver will write file: {}\n\n'.format( self.options.scenario + '.lp' ))
+
+ yield 'Reading data files.'
+ SE.write( '[ ] Reading data files.'); SE.flush()
+ self.txt_file.write( 'Reading data files.')
+ begin = time()
+ duration = lambda: time() - begin
+
+ modeldata = DataPortal( model=self.model )
+ # Recreate the pyomo command's ability to specify multiple "dot dat" files
+ # on the command lin
+ for fname in self.options.dot_dat:
+ if fname[-4:] != '.dat':
+ msg = "InputError: expecting a dot dat (e.g., data.dat) file, found '{}'\n"
+ raise Exception( msg.format( fname ))
+ modeldata.load( filename=fname )
+ yield '\t\t\t\t\t[%8.2f]\n' % duration()
+ SE.write( '\r[%8.2f]\n' % duration() )
+ self.txt_file.write( '[%8.2f]\n' % duration() )
+
+ yield 'Creating Temoa model instance.'
+ SE.write( '[ ] Creating Temoa model instance.'); SE.flush()
+ self.txt_file.write( 'Creating Temoa model instance.')
+
+ self.instance = self.model.create_instance( modeldata )
+ yield '\t\t\t\t[%8.2f]\n' % duration()
+ SE.write( '\r[%8.2f]\n' % duration() )
+ self.txt_file.write( '[%8.2f]\n' % duration() )
+
+ except Exception as model_exc:
+ yield "Exception found in create_temoa_instance\n"
+ SE.write("Exeception found in create_temoa_instance\n")
+ self.txt_file.write("Exception found in create_temoa_instance\n")
+ yield str(model_exc)
+ SE.write(str(model_exc))
+ self.txt_file.write(str(model_exc))
+ raise model_exc
+
+
+ def solve_temoa_instance (self):
+ '''Solve a Temoa instance.'''
+
+ begin = time()
+ duration = lambda: time() - begin
+ try:
+ yield 'Solving.'
+ SE.write( '[ ] Solving.'); SE.flush()
+ self.txt_file.write( 'Solving.')
+ if self.optimizer:
+ self.result = self.optimizer.solve( self.instance,
+ keepfiles=self.options.keepPyomoLP,
+ symbolic_solver_labels=self.options.keepPyomoLP )
+ yield '\t\t\t\t\t\t[%8.2f]\n' % duration()
+ SE.write( '\r[%8.2f]\n' % duration() )
+ self.txt_file.write( '[%8.2f]\n' % duration() )
+ # return signal handlers to defaults, again
+ signal(SIGINT, default_int_handler)
+
+ # ... print the easier-to-read/parse format
+ msg = '[ ] Calculating reporting variables and formatting results.'
+ yield 'Calculating reporting variables and formatting results.'
+ SE.write( msg ); SE.flush()
+ self.txt_file.write( 'Calculating reporting variables and formatting results.')
+ self.instance.solutions.store_to(self.result)
+ formatted_results = pformat_results( self.instance, self.result, self.options )
+ yield '\t[%8.2f]\n' % duration()
+ SE.write( '\r[%8.2f\n' % duration() )
+ self.txt_file.write( '[%8.2f]\n' % duration() )
+ yield formatted_results.getvalue() + '\n'
+ SO.write( formatted_results.getvalue() )
+ self.txt_file.write( formatted_results.getvalue() )
+ else:
+ yield '\r---------- Not solving: no available solver\n'
+ SE.write( '\r---------- Not solving: no available solver\n' )
+ self.txt_file.write( '\r---------- Not solving: no available solver\n' )
+
+ except BaseException as model_exc:
+ yield "Exception found in solve_temoa_instance\n"
+ SE.write("Exception found in solve_temoa_instance\n")
+ self.txt_file.write("Exception found in solve_temoa_instance\n")
+ yield str(model_exc)+'\n'
+ SE.write(str(model_exc))
+ self.txt_file.write(str(model_exc))
+ raise model_exc
+
+ def handle_files(self, log_name):
+ """Handle log and LP file assuming user called with config file or from interface."""
+ if isinstance(self.options, TemoaConfig) and self.options.saveTEXTFILE:
+ for inpu in self.options.dot_dat:
+ file_ty = reg_exp.search(r"\b([\w-]+)\.(\w+)\b", inpu)
+ new_dir = self.options.path_to_db_io+os.sep+file_ty.group(1)+'_'+self.options.scenario+'_model'
+ if path.isfile(self.options.path_to_logs+os.sep+log_name) and path.exists(new_dir):
+ copyfile(self.options.path_to_logs+os.sep+log_name, new_dir+os.sep+self.options.scenario+'_OutputLog.log')
+
+ if isinstance(self.options, TemoaConfig) and self.options.keepPyomoLP:
+ for inpu in self.options.dot_dat:
+ file_ty = reg_exp.search(r"\b([\w-]+)\.(\w+)\b", inpu)
+
+ new_dir = self.options.path_to_db_io+os.sep+file_ty.group(1)+'_'+self.options.scenario+'_model'
+
+ for files in os.listdir(self.options.path_to_lp_files):
+ if files.endswith(".lp"):
+ lpfile = files
+ else:
+ if files == "README.txt":
+ continue
+ os.remove(self.options.path_to_lp_files+os.sep+files)
+
+ if path.exists(new_dir):
+ move(self.options.path_to_lp_files+os.sep+lpfile, new_dir+os.sep+self.options.scenario+'.lp')
+
+
+def get_solvers():
+ """Return the solvers avaiable on the system."""
+ from logging import getLogger
+
+ logger = getLogger('pyomo.solvers')
+ logger_status = logger.disabled
+ logger.disabled = True # no need for warnings: it's what we're testing!
+
+ available_solvers = set()
+ for sname in SF.services(): # list of solver interface names
+ # initial underscore ('_'): Pyomo's method to mark non-public plugins
+ if '_' == sname[0]: continue
+
+ solver = SF( sname )
+ if not solver: continue
+
+ if 'os' == sname: continue # Workaround current bug in Coopr
+ if not solver.available( exception_flag=False ): continue
+ available_solvers.add( sname )
+
+ logger.disabled = logger_status # put back the way it was.
+
+ if available_solvers:
+ if 'cplex' in available_solvers:
+ default_solver = 'cplex'
+ elif 'gurobi' in available_solvers:
+ default_solver = 'gurobi'
+ elif 'cbc' in available_solvers:
+ default_solver = 'cbc'
+ elif 'glpk' in available_solvers:
+ default_solver = 'glpk'
+ else:
+ default_solver = iter(available_solvers).next()
+ else:
+ default_solver = 'NONE'
+ SE.write('\nNOTICE: Pyomo did not find any suitable solvers. Temoa will '
+ 'not be able to solve any models. If you need help, ask on the '
+ 'Temoa Project forum: http://temoaproject.org/\n\n' )
+
+ return (available_solvers, default_solver)
+
+
+
+def parse_args ( ):
+ """Parse arguments specfied from command line or in config file."""
+ import argparse, sys
+ import os, re
+ from os.path import dirname, abspath
+
+ available_solvers, default_solver = get_solvers()
+
+ parser = argparse.ArgumentParser()
+ parser.prog = path.basename( argv[0].strip('/') )
+
+ parser.add_argument('dot_dat',
+ type=str,
+ nargs='*',
+ help='AMPL-format data file(s) with which to create a model instance. '
+ 'e.g. "data.dat"'
+ )
+
+ parser.add_argument( '--path_to_logs',
+ help='Path to where debug logs will be generated by default. See folder debug_logs in db_io.',
+ action='store',
+ dest='path_to_logs',
+ default=re.sub('temoa_model$', 'db_io', dirname(abspath(__file__)))+os.sep+"debug_logs"
+ )
+
+ parser.add_argument( '--config',
+ help='Path to file containing configuration information.',
+ action='store',
+ dest='config',
+ default=None
+ )
+
+ parser.add_argument('--solver',
+ help="Which backend solver to use. See 'pyomo --help-solvers' for a list "
+ 'of solvers with which Pyomo can interface. The list shown here is '
+ 'what Pyomo can currently find on this system. [Default: {}]'
+ .format(default_solver),
+ action='store',
+ choices=sorted(available_solvers),
+ dest='solver',
+ default=default_solver)
+
+ options = parser.parse_args()
+
+ # Can't specify keeping the LP file without config file, so set this
+ # attribute to false
+ options.keepPyomoLP = False
+
+ # If the user specifies the config flag, then call TemoaConfig and overwrite
+ # the argument parser above.
+ if options.config:
+ config_flag = 1 #flag indicates config file was used.
+ try:
+ temoa_config = TemoaConfig(d_solver=default_solver)
+ temoa_config.build(config=options.config)
+ SE.write(repr(temoa_config))
+ options = temoa_config
+ SE.write('\nPlease press enter to continue or Ctrl+C to quit.\n')
+ #raw_input() # Give the user a chance to confirm input
+ if options.abort_temoa:
+ return
+ except KeyboardInterrupt:
+ SE.write('\n\nUser requested quit. Exiting Temoa ...\n')
+ raise SystemExit()
+ else:
+ config_flag = 0 #flag indicates config file was not used.
+
+ s_choice = str( options.solver ).upper()
+ SE.write('Notice: Using the {} solver interface.\n'.format( s_choice ))
+ SE.flush()
+
+ SE.write("Continue Operation? [Press enter to continue or CTRL+C to abort]\n")
+ SE.flush()
+ # raw_input() # Give the user a chance to confirm input # JAB 2019-09-25
+
+ return options, config_flag
+
diff --git a/temoa_stochastic/temoa_model/temoa_stochastic.py b/temoa_stochastic/temoa_model/temoa_stochastic.py
new file mode 100644
index 0000000..ceea926
--- /dev/null
+++ b/temoa_stochastic/temoa_model/temoa_stochastic.py
@@ -0,0 +1,206 @@
+#!/usr/bin/env python
+
+"""
+Tools for Energy Model Optimization and Analysis (Temoa):
+An open source framework for energy systems optimization modeling
+
+Copyright (C) 2015, NC State University
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+A complete copy of the GNU General Public License v2 (GPLv2) is available
+in LICENSE.txt. Users uncompressing this from an archive may not have
+received this license file. If not, see
+
+Example: pyomo_python {0} options/utopia_coal_vs_nuc.py
+
+For information about the options_to_import.py file, please see
+options/README.txt
+""".format( sys.argv[0] )
+ )
+
+ raise SystemExit
+
+def main ( ):
+ from os import getcwd
+ from time import clock
+
+ if len(sys.argv) < 2:
+ usage()
+ module_name = sys.argv[1][:-3].replace('/', '.') # remove the '.py'
+
+ try:
+ __import__(module_name)
+ opts = sys.modules[ module_name ]
+
+ except ImportError:
+ msg = ('Unable to import {}.\n\nRun this script with no arguments for '
+ 'more information.\n')
+ SE.write( msg.format( sys.argv[1] ) )
+ raise
+
+ try:
+ opts.dirname
+ except AttributeError:
+ opts.dirname = module_name.split('.')[-1]
+
+ global verbose
+ verbose = opts.verbose
+
+ cwd = getcwd()
+
+ begin = clock()
+ duration = lambda: clock() - begin
+
+ inform( '[ ] Setting up working directory (%s)' % opts.dirname )
+ setup_directory( opts.dirname, opts.force )
+ inform( '\r[%6.2f\n' % duration() )
+
+ inform( '[ ] Import model definition (%s)' % opts.modelpath )
+ mp = opts.modelpath
+ modelbase = os.path.basename(mp)[:-3]
+ modeldir = os.path.abspath( os.path.dirname( mp ))
+
+ sys.path.insert(0, modeldir)
+ _temp = __import__(modelbase, globals(), locals(), ('model',))
+ M = _temp.model
+ del _temp
+ sys.path.pop(0)
+
+ test_model_parameters( M, opts )
+
+ inform( '\r[%6.2f\n' % duration() )
+
+ inform( '[ ] Create concrete instance (%s)' % opts.dotdatpath )
+ ins = M.create( opts.dotdatpath )
+ inform( '\r[%6.2f\n' % duration() )
+
+ global instance
+ instance = ins
+
+ inform( '[ ] Collecting stochastic points from model (%s)' % M.name )
+ all_spoints = sorted( getattr(ins, opts.stochasticset).value )
+ try:
+ spoints = list(opts.stochastic_points)
+ except AttributeError:
+ spoints = all_spoints
+
+ inform( '\r[%6.2f\n' % duration() )
+
+ # used for friendlier error checking
+ Param.stochasticset = opts.stochasticset
+
+ os.chdir( opts.dirname )
+ inform( '[ ] Building tree: ')
+ tree = create_tree( all_spoints[:], spoints[:], opts ) # give an intentional copy
+ inform( '\r[%6.2f\n' % duration() )
+
+ global node_count
+ node_count = 0
+
+ inform( '[ ] Writing scenario "dot dat" files: ')
+ tree.write_dat_files()
+ write_scenario_file( all_spoints, tree )
+ inform( '\r[%6.2f] Writing scenario "dot dat" files\n' % duration() )
+
+ os.chdir( cwd )
+ inform( '[ ] Copying ReferenceModel.dat as scenario tree root' )
+ copyfile( opts.dotdatpath, '%s/ReferenceModel.dat' % opts.dirname)
+ copyfile( opts.dotdatpath, '%s/R.dat' % opts.dirname)
+ inform( '\r[%6.2f\n' % duration() )
+
+
+if '__main__' == __name__:
+ try:
+ main()
+ except Exception, e:
+ if '--debug' in sys.argv:
+ raise
+
+ msg = ('\n\nIf you need more verbose (potentially helpful) information '
+ 'about this error, you can run this program again, and add the'
+ ' "--debug" command line flag.\n')
+ msg = '\n\n' + str(e) + msg
+ SE.write(msg)
diff --git a/temoa_stochastic/tools/generate_scenario_tree.py b/temoa_stochastic/tools/generate_scenario_tree.py
new file mode 100644
index 0000000..1c9ede4
--- /dev/null
+++ b/temoa_stochastic/tools/generate_scenario_tree.py
@@ -0,0 +1,647 @@
+#!/usr/bin/env pyomo_python
+
+"""
+Tools for Energy Model Optimization and Analysis (Temoa):
+An open source framework for energy systems optimization modeling
+
+Copyright (C) 2015, NC State University
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+A complete copy of the GNU General Public License v2 (GPLv2) is available
+in LICENSE.txt. Users uncompressing this from an archive may not have
+received this license file. If not, see
+
+Example: pyomo_python {0} options/utopia_coal_vs_nuc.py
+
+For information about the options_to_import.py file, please see
+options/README.txt
+""".format( sys.argv[0] )
+ )
+
+ raise SystemExit
+
+def main ( ):
+ from os import getcwd
+ from os.path import abspath, basename, dirname
+ from time import clock
+
+ if len(sys.argv) < 2:
+ usage()
+ module_name = sys.argv[1][:-3].replace('/', '.') # remove the '.py'
+
+ mbase = basename( module_name )[:-3]
+ mdir = abspath( dirname( module_name ))
+ sys.path.insert(0, mdir)
+
+ try:
+ __import__(module_name)
+ opts = sys.modules[ module_name ]
+ sys.path.pop(0)
+
+ except ImportError:
+ msg = ('Unable to import {}.\n\nRun this script with no arguments for '
+ 'more information.\n')
+ SE.write( msg.format( sys.argv[1] ) )
+ raise
+
+ try:
+ opts.dirname
+ except AttributeError:
+ opts.dirname = module_name.split('.')[-1]
+
+ global verbose
+ verbose = opts.verbose
+
+ cwd = getcwd()
+
+ begin = clock()
+ duration = lambda: clock() - begin
+
+ inform( '[ ] Setting up working directory (%s)' % opts.dirname )
+ setup_directory( opts.dirname, opts.force )
+ inform( '\r[%6.2f\n' % duration() )
+
+ inform( '[ ] Import model definition (%s)' % opts.modelpath )
+ mp = opts.modelpath
+ modelbase = basename(mp)[:-3]
+ modeldir = abspath( dirname( mp ))
+
+ sys.path.insert(0, modeldir)
+ _temp = __import__(modelbase, globals(), locals(), ('model',))
+ M = _temp.model
+ del _temp
+ sys.path.pop(0)
+
+ test_model_parameters( M, opts )
+
+ inform( '\r[%6.2f\n' % duration() )
+
+ inform( '[ ] Create concrete instance (%s)' % opts.dotdatpath )
+ ins = M.create( opts.dotdatpath )
+ inform( '\r[%6.2f\n' % duration() )
+
+ global instance
+ instance = ins
+
+ inform( '[ ] Collecting stochastic points from model (%s)' % M.name )
+ all_spoints = sorted( getattr(ins, opts.stochasticset).value )
+ try:
+ spoints = list(opts.stochastic_points)
+ except AttributeError:
+ spoints = all_spoints
+
+ inform( '\r[%6.2f\n' % duration() )
+
+ # used for friendlier error checking
+ Param.stochasticset = opts.stochasticset
+
+ os.chdir( opts.dirname )
+ inform( '[ ] Building tree: ')
+ tree = create_tree( all_spoints[:], spoints[:], opts ) # give an intentional copy
+ inform( '\r[%6.2f\n' % duration() )
+
+ global node_count
+ node_count = 0
+
+ inform( '[ ] Writing scenario "dot dat" files: ')
+ tree.write_dat_files()
+ write_scenario_file( all_spoints, tree )
+ inform( '\r[%6.2f] Writing scenario "dot dat" files\n' % duration() )
+
+ os.chdir( cwd )
+ inform( '[ ] Copying ReferenceModel.dat as scenario tree root' )
+ copyfile( opts.dotdatpath, '%s/ReferenceModel.dat' % opts.dirname)
+ copyfile( opts.dotdatpath, '%s/R.dat' % opts.dirname)
+ inform( '\r[%6.2f\n' % duration() )
+
+
+if '__main__' == __name__:
+ try:
+ main()
+ except Exception, e:
+ if '--debug' in sys.argv:
+ raise
+
+ msg = ('\n\nIf you need more verbose (potentially helpful) information '
+ 'about this error, you can run this program again, and add the'
+ ' "--debug" command line flag.\n')
+ msg = '\n\n' + str(e) + msg
+ SE.write(msg)
diff --git a/temoa_stochastic/tools/generate_scenario_tree_JB.py b/temoa_stochastic/tools/generate_scenario_tree_JB.py
new file mode 100644
index 0000000..6ff8103
--- /dev/null
+++ b/temoa_stochastic/tools/generate_scenario_tree_JB.py
@@ -0,0 +1,703 @@
+#!/usr/bin/env pyomo_python
+
+"""
+Tools for Energy Model Optimization and Analysis (Temoa):
+An open source framework for energy systems optimization modeling
+
+Copyright (C) 2015, NC State University
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+A complete copy of the GNU General Public License v2 (GPLv2) is available
+in LICENSE.txt. Users uncompressing this from an archive may not have
+received this license file. If not, see
+
+Example: pyomo_python {0} options/utopia_coal_vs_nuc.py
+
+For information about the options_to_import.py file, please see
+options/README.txt
+""".format( sys.argv[0] )
+ )
+
+ raise SystemExit
+
+def main ( ):
+ from os import getcwd
+ from os.path import abspath, basename, dirname
+ from time import clock
+
+ if len(sys.argv) < 2:
+ usage()
+ module_name = sys.argv[1][:-3].replace('/', '.') # remove the '.py'
+
+ mbase = basename( module_name )[:-3]
+ mdir = abspath( dirname( module_name ))
+ sys.path.insert(0, mdir)
+
+ try:
+ __import__(module_name)
+ opts = sys.modules[ module_name ]
+ sys.path.pop(0)
+
+ except ImportError:
+ msg = ('Unable to import {}.\n\nRun this script with no arguments for '
+ 'more information.\n')
+ SE.write( msg.format( sys.argv[1] ) )
+ raise
+
+ try:
+ opts.dirname
+ except AttributeError:
+ opts.dirname = module_name.split('.')[-1]
+
+ global verbose
+ verbose = opts.verbose
+
+ cwd = getcwd()
+
+ begin = clock()
+ duration = lambda: clock() - begin
+
+ inform( '[ ] Setting up working directory (%s)' % opts.dirname )
+ setup_directory( opts.dirname, opts.force )
+ inform( '\r[%6.2f\n' % duration() )
+
+ inform( '[ ] Import model definition (%s)' % opts.modelpath )
+ mp = opts.modelpath
+ modelbase = basename(mp)[:-3]
+ modeldir = abspath( dirname( mp ))
+
+ sys.path.insert(0, modeldir)
+ _temp = __import__(modelbase, globals(), locals(), ('model',))
+ M = _temp.model
+ del _temp
+ sys.path.pop(0)
+
+ test_model_parameters( M, opts )
+
+ inform( '\r[%6.2f\n' % duration() )
+
+ inform( '[ ] Create concrete instance (%s)' % opts.dotdatpath )
+ ins = M.create( opts.dotdatpath )
+ inform( '\r[%6.2f\n' % duration() )
+
+ global instance
+ instance = ins
+
+ inform( '[ ] Collecting stochastic points from model (%s)' % M.name )
+ all_spoints = sorted( getattr(ins, opts.stochasticset).value )
+ try:
+ spoints = list(opts.stochastic_points)
+ except AttributeError:
+ spoints = all_spoints
+
+ inform( '\r[%6.2f\n' % duration() )
+
+ # used for friendlier error checking
+ Param.stochasticset = opts.stochasticset
+
+ os.chdir( opts.dirname )
+ inform( '[ ] Building tree: ')
+ tree = create_tree( all_spoints[:], spoints[:], opts ) # give an intentional copy
+ inform( '\r[%6.2f\n' % duration() )
+
+ global node_count
+ node_count = 0
+
+ inform( '[ ] Writing scenario "dot dat" files: ')
+ tree.write_dat_files()
+ write_scenario_file( all_spoints, tree )
+ inform( '\r[%6.2f] Writing scenario "dot dat" files\n' % duration() )
+
+ os.chdir( cwd )
+ inform( '[ ] Copying ReferenceModel.dat as scenario tree root' )
+ copyfile( opts.dotdatpath, '%s/ReferenceModel.dat' % opts.dirname)
+ copyfile( opts.dotdatpath, '%s/R.dat' % opts.dirname)
+ inform( '\r[%6.2f\n' % duration() )
+
+
+if '__main__' == __name__:
+ try:
+ main()
+ except Exception, e:
+ if '--debug' in sys.argv:
+ raise
+
+ msg = ('\n\nIf you need more verbose (potentially helpful) information '
+ 'about this error, you can run this program again, and add the'
+ ' "--debug" command line flag.\n')
+ msg = '\n\n' + str(e) + msg
+ SE.write(msg)
diff --git a/temoa_stochastic/tools/generate_scenario_tree_expanded.py b/temoa_stochastic/tools/generate_scenario_tree_expanded.py
new file mode 100644
index 0000000..1c9ede4
--- /dev/null
+++ b/temoa_stochastic/tools/generate_scenario_tree_expanded.py
@@ -0,0 +1,647 @@
+#!/usr/bin/env pyomo_python
+
+"""
+Tools for Energy Model Optimization and Analysis (Temoa):
+An open source framework for energy systems optimization modeling
+
+Copyright (C) 2015, NC State University
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+A complete copy of the GNU General Public License v2 (GPLv2) is available
+in LICENSE.txt. Users uncompressing this from an archive may not have
+received this license file. If not, see
+
+Example: pyomo_python {0} options/utopia_coal_vs_nuc.py
+
+For information about the options_to_import.py file, please see
+options/README.txt
+""".format( sys.argv[0] )
+ )
+
+ raise SystemExit
+
+def main ( ):
+ from os import getcwd
+ from os.path import abspath, basename, dirname
+ from time import clock
+
+ if len(sys.argv) < 2:
+ usage()
+ module_name = sys.argv[1][:-3].replace('/', '.') # remove the '.py'
+
+ mbase = basename( module_name )[:-3]
+ mdir = abspath( dirname( module_name ))
+ sys.path.insert(0, mdir)
+
+ try:
+ __import__(module_name)
+ opts = sys.modules[ module_name ]
+ sys.path.pop(0)
+
+ except ImportError:
+ msg = ('Unable to import {}.\n\nRun this script with no arguments for '
+ 'more information.\n')
+ SE.write( msg.format( sys.argv[1] ) )
+ raise
+
+ try:
+ opts.dirname
+ except AttributeError:
+ opts.dirname = module_name.split('.')[-1]
+
+ global verbose
+ verbose = opts.verbose
+
+ cwd = getcwd()
+
+ begin = clock()
+ duration = lambda: clock() - begin
+
+ inform( '[ ] Setting up working directory (%s)' % opts.dirname )
+ setup_directory( opts.dirname, opts.force )
+ inform( '\r[%6.2f\n' % duration() )
+
+ inform( '[ ] Import model definition (%s)' % opts.modelpath )
+ mp = opts.modelpath
+ modelbase = basename(mp)[:-3]
+ modeldir = abspath( dirname( mp ))
+
+ sys.path.insert(0, modeldir)
+ _temp = __import__(modelbase, globals(), locals(), ('model',))
+ M = _temp.model
+ del _temp
+ sys.path.pop(0)
+
+ test_model_parameters( M, opts )
+
+ inform( '\r[%6.2f\n' % duration() )
+
+ inform( '[ ] Create concrete instance (%s)' % opts.dotdatpath )
+ ins = M.create( opts.dotdatpath )
+ inform( '\r[%6.2f\n' % duration() )
+
+ global instance
+ instance = ins
+
+ inform( '[ ] Collecting stochastic points from model (%s)' % M.name )
+ all_spoints = sorted( getattr(ins, opts.stochasticset).value )
+ try:
+ spoints = list(opts.stochastic_points)
+ except AttributeError:
+ spoints = all_spoints
+
+ inform( '\r[%6.2f\n' % duration() )
+
+ # used for friendlier error checking
+ Param.stochasticset = opts.stochasticset
+
+ os.chdir( opts.dirname )
+ inform( '[ ] Building tree: ')
+ tree = create_tree( all_spoints[:], spoints[:], opts ) # give an intentional copy
+ inform( '\r[%6.2f\n' % duration() )
+
+ global node_count
+ node_count = 0
+
+ inform( '[ ] Writing scenario "dot dat" files: ')
+ tree.write_dat_files()
+ write_scenario_file( all_spoints, tree )
+ inform( '\r[%6.2f] Writing scenario "dot dat" files\n' % duration() )
+
+ os.chdir( cwd )
+ inform( '[ ] Copying ReferenceModel.dat as scenario tree root' )
+ copyfile( opts.dotdatpath, '%s/ReferenceModel.dat' % opts.dirname)
+ copyfile( opts.dotdatpath, '%s/R.dat' % opts.dirname)
+ inform( '\r[%6.2f\n' % duration() )
+
+
+if '__main__' == __name__:
+ try:
+ main()
+ except Exception, e:
+ if '--debug' in sys.argv:
+ raise
+
+ msg = ('\n\nIf you need more verbose (potentially helpful) information '
+ 'about this error, you can run this program again, and add the'
+ ' "--debug" command line flag.\n')
+ msg = '\n\n' + str(e) + msg
+ SE.write(msg)
diff --git a/temoa_stochastic/tools/jobTemoa.pbs b/temoa_stochastic/tools/jobTemoa.pbs
new file mode 100644
index 0000000..dfd5907
--- /dev/null
+++ b/temoa_stochastic/tools/jobTemoa.pbs
@@ -0,0 +1,61 @@
+#! /bin/bash
+
+# This is a simple job submission script that can be adapted for your needs.
+# At the very least, change the name of the program (line 10),
+# number of nodes requested (line 16) and
+# wallclock time requested (line 19) and
+# your program arguments (line 48)
+
+# Name of the program (used to produce standard output and error logs - Eg. test.o### )
+#PBS -N test
+# Combine both error and output logs
+#PBS -j oe
+
+# Change nodes as desired below
+# ppn refers to processes per node which is usually equal to number of cores (32 in our case)
+#PBS -l nodes=2:ppn=32
+
+# Wall clock time limit in hh:mm:ss format
+#PBS -l walltime=72:00:00
+
+# Available queues are short (5 min), low, medium and high priority.
+# medium is appropriate for most users
+#PBS -q long
+
+# If you wish to export environment variables, use both lines below
+#PBS -V
+# Just note that HYDRA_HOST_FILE shouldn't be set in this environment
+unset HYDRA_HOST_FILE
+
+# If you wish to receive email, update email and
+# remove first '#' from line below
+# #PBS -M username@ncsu.edu
+ # a mail is sent when the job is aborted by the batch system.
+ # b mail is sent when the job begins execution.
+ # e mail is sent when the job terminates.
+#PBS -m abe
+
+# Change to the program's directory
+cd /home/arqueiroz/temoa/stochastic/usdatabase_64n
+echo "Directory: $PBS_O_WORKDIR"
+date
+echo "Number of nodes is ${PBS_NUM_NODES}"
+echo "Number of cores is ${PBS_NP}"
+# If you wish to print the nodes on which your program ran, uncomment line below
+# cat $PBS_NODEFILE
+
+# TODO: Replace cpi with your program and arguments
+#mpiexec -n $PBS_NP -machinefile $PBS_NODEFILE ./cpi
+export PYRO_NS_PORT=9096
+#mpiexec -n $PBS_NP -machinefile $PBS_NODEFILE \
+#-np 1 /home/arqueiroz/anaconda2/bin/pyomo_ns : \
+#-np 1 /home/arqueiroz/anaconda2/bin/dispatch_srvr : \
+#-np 3 /home/arqueiroz/anaconda2/bin/phsolverserver : \
+#-np 1 /home/arqueiroz/anaconda2/bin/runph --solver=cplex --solver-manager=phpyro --shutdown-pyro -m models -i scenariodata --default-rho=1.0
+mpiexec -np 1 /home/arqueiroz/anaconda2/bin/pyomo_ns -n localhost : -np 1 /home/arqueiroz/anaconda2/bin/dispatch_srvr localhost : -np 3 /home/arqueiroz/anaconda2/bin/phsolverserver : -np 1 /home/arqueiroz/anaconda2/bin/runph --solver=cplex --solver-manager=phpyro --shutdown-pyro --traceback -m ../../temoa_model/ -i ./ --default-rho=1
+
+# mpiexec can detect number of available cores by default
+# So above is equivalent to line below. But use the detailed version above, as that
+# explicitly identifies number of cores etc.
+# mpiexec ./cpi
+
diff --git a/temoa_stochastic/tools/legacy_files/ef_writer_script_old.py b/temoa_stochastic/tools/legacy_files/ef_writer_script_old.py
new file mode 100644
index 0000000..8efd08d
--- /dev/null
+++ b/temoa_stochastic/tools/legacy_files/ef_writer_script_old.py
@@ -0,0 +1,680 @@
+# _________________________________________________________________________
+#
+# Pyomo: Python Optimization Modeling Objects
+# Copyright (c) 2014 Sandia Corporation.
+# Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+# the U.S. Government retains certain rights in this software.
+# This software is distributed under the BSD License.
+# _________________________________________________________________________
+
+import gc
+import os
+import sys
+import time
+import random
+from optparse import OptionParser, OptionGroup
+
+from pyutilib.pyro import shutdown_pyro_components
+import pyutilib.misc
+
+from pyomo.core.base import maximize, minimize
+from pyomo.core.base.symbol_map import symbol_map_from_instance
+from pyomo.util import pyomo_command
+from pyomo.util.plugin import ExtensionPoint
+from pyomo.opt.base import (SolverFactory,
+ PersistentSolver,
+ ProblemFormat)
+from pyomo.opt.base.solvers import UnknownSolver
+from pyomo.opt.parallel import SolverManagerFactory
+
+from pyomo.pysp.scenariotree.instance_factory import \
+ ScenarioTreeInstanceFactory
+from pyomo.pysp.ef import write_ef, create_ef_instance
+from pyomo.pysp.solutionwriter import ISolutionWriterExtension
+from pyomo.pysp.util.misc import launch_command
+
+#
+# utility method to construct an option parser for ef writer arguments
+#
+
+def construct_ef_writer_options_parser(usage_string):
+
+ solver_list = SolverFactory.services()
+ solver_list = sorted( filter(lambda x: '_' != x[0], solver_list) )
+ solver_help = \
+ "Specify the solver with which to solve the extensive form. The " \
+ "following solver types are currently supported: %s; Default: cplex"
+ solver_help %= ', '.join( solver_list )
+
+ parser = OptionParser()
+ parser.usage=usage_string
+
+ inputOpts = OptionGroup( parser, 'Input Options' )
+ scenarioTreeOpts = OptionGroup( parser, 'Scenario Tree Options' )
+ efOpts = OptionGroup( parser, 'EF Options' )
+ ccOpts = OptionGroup( parser, 'Chance Constraint Options' )
+ solverOpts = OptionGroup( parser, 'Solver Options' )
+ outputOpts = OptionGroup( parser, 'Output Options' )
+ otherOpts = OptionGroup( parser, 'Other Options' )
+ parser.add_option_group( inputOpts )
+ parser.add_option_group( scenarioTreeOpts )
+ parser.add_option_group( efOpts )
+ parser.add_option_group( ccOpts )
+ parser.add_option_group( solverOpts )
+ parser.add_option_group( outputOpts )
+ parser.add_option_group( otherOpts )
+
+ inputOpts.add_option('-i','--instance-directory',
+ help='The directory in which all instance (reference and scenario) definitions are stored. This option is required if no callback is found in the model file.',
+ action='store',
+ dest='instance_directory',
+ type='string',
+ default=None)
+ inputOpts.add_option('-m','--model-directory',
+ help='The directory in which all model (reference and scenario) definitions are stored. Default is ".".',
+ action='store',
+ dest='model_directory',
+ type='string',
+ default='.')
+ def objective_sense_callback(option, opt_str, value, parser):
+ if value in ('min','minimize',minimize):
+ parser.values.objective_sense = minimize
+ elif value in ('max','maximize',maximize):
+ parser.values.objective_sense = maximize
+ else:
+ parser.values.objective_sense = None
+ inputOpts.add_option('-o','--objective-sense-stage-based',
+ help='The objective sense to use for the auto-generated scenario instance objective, which is equal to the '
+ 'sum of the scenario-tree stage costs. Default is None, indicating an Objective has been declared on the '
+ 'reference model.',
+ action="callback",
+ dest="objective_sense",
+ type="choice",
+ choices=[maximize,'max','maximize',minimize,'min','minimize',None],
+ default=None,
+ callback=objective_sense_callback)
+
+ scenarioTreeOpts.add_option('--scenario-tree-seed',
+ help="The random seed associated with manipulation operations on the scenario tree (e.g., down-sampling). Default is None, indicating unassigned.",
+ action="store",
+ dest="scenario_tree_random_seed",
+ type="int",
+ default=random.getrandbits(100))
+ scenarioTreeOpts.add_option('--scenario-tree-downsample-fraction',
+ help="The proportion of the scenarios in the scenario tree that are actually used. Specific scenarios are selected at random. Default is 1.0, indicating no down-sampling.",
+ action="store",
+ dest="scenario_tree_downsample_fraction",
+ type="float",
+ default=1.0)
+
+ efOpts.add_option('--cvar-weight',
+ help='The weight associated with the CVaR term in the risk-weighted objective formulation. Default is 1.0. If the weight is 0, then *only* a non-weighted CVaR cost will appear in the EF objective - the expected cost component will be dropped.',
+ action='store',
+ dest='cvar_weight',
+ type='float',
+ default=1.0)
+ efOpts.add_option('--generate-weighted-cvar',
+ help='Add a weighted CVaR term to the primary objective',
+ action='store_true',
+ dest='generate_weighted_cvar',
+ default=False)
+ efOpts.add_option('--risk-alpha',
+ help='The probability threshold associated with cvar (or any future) risk-oriented performance metrics. Default is 0.95.',
+ action='store',
+ dest='risk_alpha',
+ type='float',
+ default=0.95)
+
+ ccOpts.add_option('--cc-alpha',
+ help='The probability threshold associated with a chance constraint. The RHS will be one minus this value. Default is 0.',
+ action='store',
+ dest='cc_alpha',
+ type='float',
+ default=0.0)
+
+ ccOpts.add_option('--cc-indicator-var',
+ help='The name of the binary variable to be used to construct a chance constraint. Default is None, which indicates no chance constraint.',
+ action='store',
+ dest='cc_indicator_var',
+ type='string',
+ default=None)
+
+ solverOpts.add_option('--mipgap',
+ help='Specifies the mipgap for the EF solve.',
+ action='store',
+ dest='mipgap',
+ type='float',
+ default=None)
+ solverOpts.add_option('--solve',
+ help='Following write of the extensive form model, solve it.',
+ action='store_true',
+ dest='solve_ef',
+ default=False)
+ solverOpts.add_option('--solver',
+ help=solver_help,
+ action='store',
+ dest='solver_type',
+ type='string',
+ default='cplex')
+ solverOpts.add_option('--solver-io',
+ help='The type of IO used to execute the solver. Different solvers support different types of IO, but the following are common options: lp - generate LP files, nl - generate NL files, python - direct Python interface, os - generate OSiL XML files.',
+ action='store',
+ dest='solver_io',
+ default=None)
+ solverOpts.add_option('--solver-manager',
+ help='The type of solver manager used to coordinate scenario sub-problem solves. Default is serial.',
+ action='store',
+ dest='solver_manager_type',
+ type='string',
+ default='serial')
+ solverOpts.add_option('--pyro-host',
+ help="The hostname to bind on when searching for a Pyro nameserver.",
+ action="store",
+ dest="pyro_host",
+ default=None)
+ solverOpts.add_option('--pyro-port',
+ help="The port to bind on when searching for a Pyro nameserver.",
+ action="store",
+ dest="pyro_port",
+ type="int",
+ default=None)
+ solverOpts.add_option('--solver-options',
+ help='Solver options for the extensive form problem.',
+ action='append',
+ dest='solver_options',
+ type='string',
+ default=[])
+ solverOpts.add_option('--disable-warmstarts',
+ help="Disable warm-starts of EF solves. Default is False.",
+ action="store_true",
+ dest="disable_warmstarts",
+ default=False)
+ solverOpts.add_option('--shutdown-pyro',
+ help="Shut down all Pyro-related components associated with the Pyro solver manager (if specified), including the dispatch server, name server, and any mip servers. Default is False.",
+ action="store_true",
+ dest="shutdown_pyro",
+ default=False)
+ solverOpts.add_option('--shutdown-pyro-workers',
+ help="Shut down PH solver servers on exit, leaving dispatcher and nameserver running. Default is False.",
+ action="store_true",
+ dest="shutdown_pyro_workers",
+ default=False)
+
+
+ outputOpts.add_option('--output-file',
+ help="The name of the extensive form output file (currently only LP and NL file formats are supported). If the option name does not end in '.lp' or '.nl', then the output format will be determined by the value of the --solver-io option, and the appropriate ending suffix will be added to the name. Default is 'efout'.",
+ action='store',
+ dest='output_file',
+ type='string',
+ default="efout")
+ outputOpts.add_option('--symbolic-solver-labels',
+ help='When interfacing with the solver, use symbol names derived from the model. For example, \"my_special_variable[1_2_3]\" instead of \"v1\". Useful for debugging. When using the ASL interface (--solver-io=nl), generates corresponding .row (constraints) and .col (variables) files. The ordering in these files provides a mapping from ASL index to symbolic model names.',
+ action='store_true',
+ dest='symbolic_solver_labels',
+ default=False)
+ outputOpts.add_option('--output-solver-log',
+ help='Output solver log during the extensive form solve.',
+ action='store_true',
+ dest='output_solver_log',
+ default=False)
+ outputOpts.add_option('--solution-writer',
+ help='The plugin invoked to write the scenario tree solution. Defaults to the empty list.',
+ action='append',
+ dest='solution_writer',
+ type='string',
+ default = [])
+ outputOpts.add_option('--verbose',
+ help='Generate verbose output, beyond the usual status output. Default is False.',
+ action='store_true',
+ dest='verbose',
+ default=False)
+ outputOpts.add_option('--output-times',
+ help="Output timing statistics for various EF components",
+ action="store_true",
+ dest="output_times",
+ default=False)
+ outputOpts.add_option('--output-instance-construction-time',
+ help="Output timing statistics for instance construction (client-side only when using PHPyro",
+ action="store_true",
+ dest="output_instance_construction_time",
+ default=False)
+ otherOpts.add_option('--disable-gc',
+ help='Disable the python garbage collecter. Default is False.',
+ action='store_true',
+ dest='disable_gc',
+ default=False)
+ otherOpts.add_option('-k','--keep-solver-files',
+ help='Retain temporary input and output files for solve.',
+ action='store_true',
+ dest='keep_solver_files',
+ default=False)
+ otherOpts.add_option('--profile',
+ help='Enable profiling of Python code. The value of this option is the number of functions that are summarized.',
+ action='store',
+ dest='profile',
+ type="int",
+ default=0)
+ otherOpts.add_option('--traceback',
+ help='When an exception is thrown, show the entire call stack. Ignored if profiling is enabled. Default is False.',
+ action='store_true',
+ dest='traceback',
+ default=False)
+ otherOpts.add_option('--compile-scenario-instances',
+ help="Replace all linear constraints on scenario instances with a more memory efficient sparse matrix representation. Default is False.",
+ action="store_true",
+ dest="compile_scenario_instances",
+ default=False)
+
+ return parser
+
+def EF_DefaultOptions():
+ parser = construct_ef_writer_options_parser("")
+ options, _ = parser.parse_args([''])
+ return options
+
+def GenerateScenarioTreeForEF(options,
+ scenario_instance_factory,
+ include_scenarios=None):
+
+ try:
+
+ scenario_tree = scenario_instance_factory.generate_scenario_tree(
+ include_scenarios=include_scenarios,
+ downsample_fraction=options.scenario_tree_downsample_fraction,
+ random_seed=options.scenario_tree_random_seed)
+
+ #
+ # print the input tree for validation/information purposes.
+ #
+ if options.verbose:
+ scenario_tree.pprint()
+
+ #
+ # validate the tree prior to doing anything serious
+ #
+ if not scenario_tree.validate():
+ raise RuntimeError("Scenario tree is invalid")
+ else:
+ if options.verbose:
+ print("Scenario tree is valid!")
+
+ start_time = time.time()
+
+ print("Constructing scenario tree instances")
+ instance_dictionary = \
+ scenario_instance_factory.construct_instances_for_scenario_tree(
+ scenario_tree,
+ output_instance_construction_time=options.output_instance_construction_time,
+ compile_scenario_instances=options.compile_scenario_instances)
+
+ if options.verbose or options.output_times:
+ print("Time to construct scenario instances=%.2f seconds"
+ % (time.time() - start_time))
+
+ print("Linking instances into scenario tree")
+ start_time = time.time()
+
+ # with the scenario instances now available, link the
+ # referenced objects directly into the scenario tree.
+ scenario_tree.linkInInstances(instance_dictionary,
+ objective_sense=options.objective_sense,
+ create_variable_ids=True)
+
+ if options.output_times:
+ print("Time link scenario tree with instances=%.2f seconds"
+ % (time.time() - start_time))
+
+ except:
+ if scenario_instance_factory is not None:
+ scenario_instance_factory.close()
+ print("Failed to initialize model and/or scenario tree data")
+ raise
+
+ return scenario_tree
+
+def CreateExtensiveFormInstance(options, scenario_tree):
+
+ start_time = time.time()
+ print("Creating extensive form instance")
+
+ # then validate the associated parameters.
+ generate_weighted_cvar = False
+ cvar_weight = None
+ risk_alpha = None
+ if options.generate_weighted_cvar is True:
+ generate_weighted_cvar = True
+ cvar_weight = options.cvar_weight
+ risk_alpha = options.risk_alpha
+
+ binding_instance = create_ef_instance(scenario_tree,
+ verbose_output=options.verbose,
+ generate_weighted_cvar=generate_weighted_cvar,
+ cvar_weight=cvar_weight,
+ risk_alpha=risk_alpha,
+ cc_indicator_var_name=options.cc_indicator_var,
+ cc_alpha=options.cc_alpha)
+
+ if options.verbose or options.output_times:
+ print("Time to construct extensive form instance=%.2f seconds"
+ %(time.time() - start_time))
+
+ return binding_instance
+
+class ExtensiveFormAlgorithm(object):
+
+ def __init__(self,
+ options,
+ binding_instance,
+ scenario_tree,
+ solver_manager,
+ solver,
+ solution_plugins=None):
+
+ self._options = options
+ self._binding_instance = binding_instance
+ self._scenario_tree = scenario_tree
+ self._solver_manager = solver_manager
+ self._solver = solver
+ self._solution_plugins = solution_plugins
+
+ def write(self):
+
+ start_time = time.time()
+
+ output_filename = os.path.expanduser(self._options.output_file)
+ suf = os.path.splitext(output_filename)[1]
+ if suf not in ['.nl','.lp']:
+ if self._solver.problem_format() == ProblemFormat.cpxlp:
+ output_filename += '.lp'
+ elif self._solver.problem_format() == ProblemFormat.nl:
+ output_filename += '.nl'
+ else:
+ raise ValueError("Could not determine output file format. "
+ "No recognized ending suffix was provided "
+ "and no format was indicated was by the "
+ "--solver-io option.")
+
+ start_time = time.time()
+ if self._options.verbose:
+ print("Starting to write extensive form")
+
+ symbol_map = write_ef(self._binding_instance,
+ output_filename,
+ self._options.symbolic_solver_labels)
+
+ print("Extensive form written to file="+output_filename)
+ if self._options.verbose or self._options.output_times:
+ print("Time to write output file=%.2f seconds"
+ % (time.time() - start_time))
+
+ return output_filename, symbol_map
+
+ def solve(self):
+
+ start_time = time.time()
+ print("Queuing extensive form solve")
+
+ if isinstance(self._solver, PersistentSolver):
+ self._solver.compile_instance(
+ self._binding_instance,
+ symbolic_solver_labels=self._options.symbolic_solver_labels)
+
+ solve_kwds = {}
+ solve_kwds['load_solutions'] = False
+ if self._options.keep_solver_files:
+ solve_kwds['keepfiles'] = True
+ if self._options.symbolic_solver_labels:
+ solve_kwds['symbolic_solver_labels'] = True
+ if self._options.output_solver_log:
+ solve_kwds['tee'] = True
+
+ if (not self._options.disable_warmstarts) and \
+ (self._solver.warm_start_capable()):
+ action_handle = self._solver_manager.queue(self._binding_instance,
+ opt=self._solver,
+ warmstart=True,
+ **solve_kwds)
+ else:
+ action_handle = self._solver_manager.queue(self._binding_instance,
+ opt=self._solver,
+ **solve_kwds)
+ print("Waiting for extensive form solve")
+ results = self._solver_manager.wait_for(action_handle)
+
+ if len(results.solution) == 0:
+ results.write()
+ raise RuntimeError("Solve failed; no solutions generated")
+
+ print("Done with extensive form solve - loading results")
+ self._binding_instance.solutions.load_from(results)
+
+ print("Storing solution in scenario tree")
+ self._scenario_tree.pullScenarioSolutionsFromInstances()
+ self._scenario_tree.snapshotSolutionFromScenarios()
+ # TODO
+ #self._scenario_tree.update_variable_statistics()
+
+ if self._options.verbose or self._options.output_times:
+ print("Time to solve and load results for the "
+ "extensive form=%.2f seconds"
+ % (time.time()-start_time))
+
+ # print *the* metric of interest.
+ root_node = self._scenario_tree._stages[0]._tree_nodes[0]
+ print("")
+ print("********************************"
+ "********************************"
+ "*******************************")
+ print(">>>THE EXPECTED SUM OF THE STAGE COST VARIABLES="
+ +str(root_node.computeExpectedNodeCost())+"<<<")
+ print("********************************"
+ "********************************"
+ "*******************************")
+
+ # handle output of solution from the scenario tree.
+ print("")
+ print("Extensive form solution:")
+ self._scenario_tree.pprintSolution()
+ print("")
+ print("Extensive form costs:")
+ self._scenario_tree.pprintCosts()
+
+ def save_solution(self, label="ef"):
+
+ if self._solution_plugins is not None:
+
+ for plugin in self._solution_plugins:
+
+ plugin.write(self._scenario_tree, label)
+
+def EFAlgorithmBuilder(options, scenario_tree):
+
+ solution_writer_plugins = ExtensionPoint(ISolutionWriterExtension)
+ for plugin in solution_writer_plugins:
+ plugin.disable()
+
+ solution_plugins = []
+ if len(options.solution_writer) > 0:
+ for this_extension in options.solution_writer:
+ if this_extension in sys.modules:
+ print("User-defined EF solution writer module="
+ +this_extension+" already imported - skipping")
+ else:
+ print("Trying to import user-defined EF "
+ "solution writer module="+this_extension)
+ # make sure "." is in the PATH.
+ original_path = list(sys.path)
+ sys.path.insert(0,'.')
+ pyutilib.misc.import_file(this_extension)
+ print("Module successfully loaded")
+ sys.path[:] = original_path # restore to what it was
+
+ # now that we're sure the module is loaded, re-enable this
+ # specific plugin. recall that all plugins are disabled
+ # by default in phinit.py, for various reasons. if we want
+ # them to be picked up, we need to enable them explicitly.
+ import inspect
+ module_to_find = this_extension
+ if module_to_find.rfind(".py"):
+ module_to_find = module_to_find.rstrip(".py")
+ if module_to_find.find("/") != -1:
+ module_to_find = module_to_find.split("/")[-1]
+
+ for name, obj in inspect.getmembers(sys.modules[module_to_find], inspect.isclass):
+ import pyomo.util
+ # the second condition gets around goofyness related to issubclass returning
+ # True when the obj is the same as the test class.
+ if issubclass(obj, pyomo.util.plugin.SingletonPlugin) and name != "SingletonPlugin":
+ for plugin in solution_writer_plugins(all=True):
+ if isinstance(plugin, obj):
+ plugin.enable()
+ solution_plugins.append(plugin)
+
+ ef_solver = SolverFactory(options.solver_type,
+ solver_io=options.solver_io)
+ if isinstance(ef_solver, UnknownSolver):
+ raise ValueError("Failed to create solver of type="+
+ options.solver_type+
+ " for use in extensive form solve")
+ if len(options.solver_options) > 0:
+ print("Initializing ef solver with options="
+ +str(options.solver_options))
+ ef_solver.set_options("".join(options.solver_options))
+ if options.mipgap is not None:
+ if (options.mipgap < 0.0) or (options.mipgap > 1.0):
+ raise ValueError("Value of the mipgap parameter for the EF "
+ "solve must be on the unit interval; "
+ "value specified="+str(options.mipgap))
+ ef_solver.options.mipgap = float(options.mipgap)
+
+ ef_solver_manager = SolverManagerFactory(options.solver_manager_type,
+ host=options.pyro_host,
+ port=options.pyro_port)
+ if ef_solver_manager is None:
+ raise ValueError("Failed to create solver manager of type="
+ +options.solver_type+
+ " for use in extensive form solve")
+
+ binding_instance = CreateExtensiveFormInstance(options, scenario_tree)
+
+ ef = ExtensiveFormAlgorithm(options,
+ binding_instance,
+ scenario_tree,
+ ef_solver_manager,
+ ef_solver,
+ solution_plugins=solution_plugins)
+
+ return ef
+
+def run_ef(options, ef):
+
+ if options.solve_ef:
+ retval = ef.solve()
+ ef.save_solution()
+ else:
+ retval = ef.write()
+
+ return retval
+
+def exec_runef(options):
+ import pyomo.solvers.plugins.smanager.phpyro
+ import pyomo.solvers.plugins.smanager.pyro
+
+ start_time = time.time()
+
+ if options.verbose:
+ print("Importing model and scenario tree files")
+
+ scenario_instance_factory = ScenarioTreeInstanceFactory(
+ options.model_directory,
+ options.instance_directory,
+ options.verbose)
+
+ if options.output_times:
+ print("Time to import model and scenario tree structure files=%.2f seconds"
+ %(time.time() - start_time))
+
+ ef = None
+ try:
+
+ scenario_tree = GenerateScenarioTreeForEF(options,
+ scenario_instance_factory)
+
+
+
+ ef = EFAlgorithmBuilder(options, scenario_tree)
+
+ run_ef(options, ef)
+
+ finally:
+
+ if ef is not None:
+ if ef._solver_manager is not None:
+
+ if isinstance(ef._solver_manager,
+ pyomo.solvers.plugins.smanager.\
+ phpyro.SolverManager_PHPyro):
+ ef._solver_manager.release_servers(
+ shutdown=option.shutdown_pyro_workers)
+ if isinstance(ef._solver_manager,
+ pyomo.solvers.plugins.smanager.\
+ pyro.SolverManager_Pyro):
+ if options.shutdown_pyro_workers:
+ ef._solver_manager.shutdown_workers()
+ ef._solver_manager.deactivate()
+ if ef._solver is not None:
+ ef._solver.deactivate()
+
+ if (isinstance(ef._solver_manager,
+ pyomo.solvers.plugins.smanager.\
+ pyro.SolverManager_Pyro) or \
+ isinstance(ef._solver_manager,
+ pyomo.solvers.plugins.smanager.phpyro.\
+ SolverManager_PHPyro)) and \
+ (options.shutdown_pyro):
+ print("Shutting down Pyro solver components")
+ shutdown_pyro_components(host=options.pyro_host,
+ port=options.pyro_port,
+ num_retries=0)
+
+ if scenario_instance_factory is not None:
+ scenario_instance_factory.close()
+
+ print("")
+ print("Total EF execution time=%.2f seconds" %(time.time() - start_time))
+ print("")
+
+ return 0
+
+def main(args=None):
+ #
+ # Top-level command that executes the runef command
+ #
+
+ #
+ # Import plugins
+ #
+ import pyomo.environ
+
+ #
+ # Parse command-line options.
+ #
+ try:
+ options_parser = \
+ construct_ef_writer_options_parser("runef [options]")
+ (options, args) = options_parser.parse_args(args=args)
+ except SystemExit as _exc:
+ # the parser throws a system exit if "-h" is specified
+ # - catch it to exit gracefully.
+ return _exc.code
+
+ return launch_command(exec_runef,
+ options,
+ error_label="runef: ",
+ disable_gc=options.disable_gc,
+ profile_count=options.profile,
+ traceback=options.traceback)
+
+@pyomo_command('runef', 'Convert a SP tfo extensive form and optimize')
+def EF_main(args=None):
+ return main(args=args)
diff --git a/temoa_stochastic/tools/legacy_files/scenariomodels.py b/temoa_stochastic/tools/legacy_files/scenariomodels.py
new file mode 100644
index 0000000..c30cf13
--- /dev/null
+++ b/temoa_stochastic/tools/legacy_files/scenariomodels.py
@@ -0,0 +1,60 @@
+# grab the pyomo modeling components.
+from pyomo.environ import *
+
+scenario_tree_model = AbstractModel()
+
+# all set/parameter values are strings, representing the names of various entities/variables.
+
+scenario_tree_model.Stages = Set(ordered=True)
+scenario_tree_model.Nodes = Set()
+
+scenario_tree_model.NodeStage = Param(scenario_tree_model.Nodes, within=scenario_tree_model.Stages)
+scenario_tree_model.Children = Set(scenario_tree_model.Nodes, within=scenario_tree_model.Nodes, ordered=True)
+scenario_tree_model.ConditionalProbability = Param(scenario_tree_model.Nodes)
+
+scenario_tree_model.Scenarios = Set(ordered=True)
+scenario_tree_model.ScenarioLeafNode = Param(scenario_tree_model.Scenarios, within=scenario_tree_model.Nodes)
+
+scenario_tree_model.StageVariables = Set(scenario_tree_model.Stages)
+scenario_tree_model.StageCostVariable = Param(scenario_tree_model.Stages)
+
+# scenario data can be populated in one of two ways. the first is "scenario-based",
+# in which a single .dat file contains all of the data for each scenario. the .dat
+# file prefix must correspond to the scenario name. the second is "node-based",
+# in which a single .dat file contains only the data for each node in the scenario
+# tree. the node-based method is more compact, but the scenario-based method is
+# often more natural when parameter data is generated via simulation. the default
+# is scenario-based.
+scenario_tree_model.ScenarioBasedData = Param(within=Boolean, default=True, mutable=True)
+
+# do we bundle, and if so, how?
+scenario_tree_model.Bundling = Param(within=Boolean, default=False, mutable=True)
+scenario_tree_model.Bundles = Set() # bundle names
+scenario_tree_model.BundleScenarios = Set(scenario_tree_model.Bundles)
+
+
+#scenario_tree_model = AbstractModel()
+
+## all set/parameter values are strings, representing the names of various entities/variables.
+
+#scenario_tree_model.Stages = Set(ordered=True)
+#scenario_tree_model.Nodes = Set()
+
+#scenario_tree_model.NodeStage = Param(scenario_tree_model.Nodes, within=scenario_tree_model.Stages)
+#scenario_tree_model.Children = Set(scenario_tree_model.Nodes, within=scenario_tree_model.Nodes, ordered=True)
+#scenario_tree_model.ConditionalProbability = Param(scenario_tree_model.Nodes)
+
+#scenario_tree_model.Scenarios = Set(ordered=True)
+#scenario_tree_model.ScenarioLeafNode = Param(scenario_tree_model.Scenarios, within=scenario_tree_model.Nodes)
+
+#scenario_tree_model.StageVariables = Set(scenario_tree_model.Stages)
+#scenario_tree_model.StageCostVariable = Param(scenario_tree_model.Stages)
+
+## scenario data can be populated in one of two ways. the first is "scenario-based",
+## in which a single .dat file contains all of the data for each scenario. the .dat
+## file prefix must correspond to the scenario name. the second is "node-based",
+## in which a single .dat file contains only the data for each node in the scenario
+## tree. the node-based method is more compact, but the scenario-based method is
+## often more natural when parameter data is generated via simulation. the default
+## is scenario-based.
+#scenario_tree_model.ScenarioBasedData = Param(within=Boolean, default=True)
\ No newline at end of file
diff --git a/temoa_stochastic/tools/morris.py b/temoa_stochastic/tools/morris.py
new file mode 100644
index 0000000..90a01ab
--- /dev/null
+++ b/temoa_stochastic/tools/morris.py
@@ -0,0 +1,191 @@
+from __future__ import division
+import time
+start_time = time.time()
+from joblib import Parallel, delayed
+import multiprocessing
+import sys
+import os
+from shutil import copyfile
+import sqlite3
+from numpy import array
+from IPython import embed as IP
+from SALib.analyze import morris
+from SALib.sample.morris import sample
+from SALib.util import read_param_file, compute_groups_matrix
+import numpy as np
+
+def evaluate(param_names, param_values,k):
+
+ m=len(param_values)
+ for j in range(0,m):
+ Newdbpath=os.getcwd()+'/db_io/dbs/Method_of_Morris'+str(k)+'.db'
+ con=sqlite3.connect(Newdbpath)
+ cur = con.cursor()
+ filter1=param_names[j][1]
+ filter2=param_names[j][2]
+ table=param_names[j][0]
+ cursor = con.execute("SELECT * FROM "+"'"+table+"'")
+ col_names = list(map(lambda x: x[0], cursor.description))
+ if len(param_names[j])==4:
+ update_var=param_names[j][3]
+ text="UPDATE "+"'"+table+"' SET "+"'"+update_var+"'=? WHERE "+"'"+col_names[0]+"'=? and "+"'"+col_names[1]+"'=?"
+ text=text.replace("'","")
+ con.execute(text, (param_values[j],filter1,filter2))
+ con.commit()
+ elif len(param_names[j])==5:
+ filter3=param_names[j][3]
+ update_var=param_names[j][4]
+ text="UPDATE "+"'"+table+"' SET "+"'"+update_var+"'=? WHERE "+"'"+col_names[0]+"'=? and "+"'"+col_names[1]+"'=? and "+"'"+col_names[2]+"'=?"
+ text=text.replace("'","")
+ con.execute(text, (param_values[j],filter1,filter2,filter3))
+ con.commit()
+ else:
+ filter3=param_names[j][3]
+ filter4=param_names[j][4]
+ update_var=param_names[j][5]
+ text="UPDATE "+"'"+table+"' SET "+"'"+update_var+"'=? WHERE "+"'"+col_names[0]+"'=? and "+"'"+col_names[1]+"'=? and "+"'"+col_names[2]+"'=? and "+"'"+col_names[3]+"'=?"
+ text=text.replace("'","")
+ con.execute(text, (param_values[j],filter1,filter2,filter3,filter4))
+ con.commit()
+ con.close()
+ NewConfigfilePath=os.getcwd()+'/temoa_model/config_sample'+str(k)
+ copyfile(os.getcwd()+'/temoa_model/config_sample',NewConfigfilePath)
+ with open(os.getcwd()+'/temoa_model/config_sample', 'r') as file:
+ data = file.readlines()
+ data[13]='--input=db_io/dbs/Method_of_Morris'+str(k)+'.db'
+ data[20]='--output=db_io/dbs/Method_of_Morris'+str(k)+'.db'
+ with open(NewConfigfilePath, 'w') as file:
+ file.writelines(data)
+ os.system('python temoa_model/ --config=temoa_model/config_sample'+str(k))
+
+ Newdbpath=os.getcwd()+'/db_io/dbs/Method_of_Morris'+str(k)+'.db'
+ con=sqlite3.connect(Newdbpath)
+ cur = con.cursor()
+ cur.execute("SELECT * FROM Output_Objective")
+ output_query = cur.fetchall()
+ for row in output_query:
+ Y_OF=row[-1]
+ cur.execute("SELECT emissions_comm, SUM(emissions) FROM Output_Emissions WHERE emissions_comm='co2'")
+ output_query = cur.fetchall()
+ for row in output_query:
+ Y_CumulativeCO2=row[-1]
+ Morris_Objectives=[]
+ Morris_Objectives.append(Y_OF)
+ Morris_Objectives.append(Y_CumulativeCO2)
+ con.close()
+ return Morris_Objectives
+
+
+#param_names = { #the first element is the name of the table, followed by fisrt, second ... filters. The name of the column which is to change comes at the end
+#0:['CostVariable',1990,'IMPGSL1',1990,'cost_variable'],
+#1:['CostVariable',2000,'IMPGSL1',1990,'cost_variable'],
+#2:['CostVariable',2010,'IMPGSL1',1990,'cost_variable'],
+#3:['CostVariable',1990,'IMPDSL1',1990,'cost_variable'],
+#4:['CostVariable',2000,'IMPDSL1',1990,'cost_variable'],
+#5:['CostVariable',2010,'IMPDSL1',1990,'cost_variable'],
+#6:['CostInvest','TXE',1990,'cost_invest'],
+#7:['CostInvest','TXE',2000,'cost_invest'],
+#8:['CostInvest','TXE',2010,'cost_invest'],
+#9:['CostInvest','SRE',1990,'cost_invest'],
+# }
+perturbation_coefficient=0.1 #minus plus 10% of the baseline values
+f= open(os.getcwd()+"/Method_of_Morris.txt","w+")
+f.close()
+param_names={}
+con=sqlite3.connect('db_io/dbs/Method_of_Morris.db')
+cur = con.cursor()
+cur.execute("SELECT * FROM CostVariable WHERE MMAnalysis is not NULL")
+output_query = cur.fetchall()
+g1=len(output_query)
+for i in range(0,len(output_query)):
+ param_names[i]=['CostVariable',output_query[i][0],output_query[i][1],output_query[i][2],'cost_variable']
+ with open(os.getcwd()+'/Method_of_Morris.txt','a') as file:
+ file.write('x'+str(i))
+ file.write(' ')
+ file.write(str(output_query[i][3]*0.9))
+ file.write(' ')
+ file.write(str(output_query[i][3]*1.1))
+ file.write(' ')
+ file.write(output_query[i][-1])
+ file.write("\n")
+cur.execute("SELECT * FROM CostInvest WHERE MMAnalysis is not NULL")
+output_query = cur.fetchall()
+g2=len(output_query)
+for i in range(0,len(output_query)):
+ param_names[i+g1]=['CostInvest',output_query[i][0],output_query[i][1],'cost_invest']
+ with open(os.getcwd()+'/Method_of_Morris.txt','a') as file:
+ file.write('x'+str(i+g1))
+ file.write(' ')
+ file.write(str(output_query[i][2]*0.9))
+ file.write(' ')
+ file.write(str(output_query[i][2]*1.1))
+ file.write(' ')
+ file.write(output_query[i][-1])
+ file.write("\n")
+cur.execute("SELECT * FROM Efficiency WHERE MMAnalysis is not NULL")
+output_query = cur.fetchall()
+g3=len(output_query)
+for i in range(0,len(output_query)):
+ param_names[i+g1+g2]=['Efficiency',output_query[i][0],output_query[i][1],output_query[i][2],output_query[i][3],'efficiency']
+ with open(os.getcwd()+'/Method_of_Morris.txt','a') as file:
+ file.write('x'+str(i+g1+g2))
+ file.write(' ')
+ file.write(str(output_query[i][4]*0.9))
+ file.write(' ')
+ file.write(str(output_query[i][4]*1.1))
+ file.write(' ')
+ file.write(output_query[i][-1])
+ file.write("\n")
+
+problem = read_param_file(os.getcwd()+'/Method_of_Morris.txt')
+param_values = sample(problem, N=3, num_levels=4, grid_jump=2, \
+ optimal_trajectories=False, local_optimization=False)
+n=len(param_values)
+for k in range(0,n):
+ Newdbpath=os.getcwd()+'/db_io/dbs/Method_of_Morris'+str(k)+'.db'
+ copyfile(os.getcwd()+'/db_io/dbs/Method_of_Morris.db',Newdbpath)
+num_cores = multiprocessing.cpu_count()
+Morris_Objectives = Parallel(n_jobs=num_cores)(delayed(evaluate)(param_names, param_values[i,:],i) for i in range(0,n))
+Morris_Objectives=array(Morris_Objectives)
+Si_OF = morris.analyze(problem, param_values, Morris_Objectives[:,0], conf_level=0.95,
+ print_to_console=False,
+ num_levels=4, grid_jump=2, num_resamples=1000)
+
+Si_CumulativeCO2 = morris.analyze(problem, param_values, Morris_Objectives[:,1], conf_level=0.95,
+ print_to_console=False,
+ num_levels=4, grid_jump=2, num_resamples=1000)
+num_vars = problem['num_vars']
+groups, unique_group_names = compute_groups_matrix(problem['groups'], num_vars)
+number_of_groups = len(unique_group_names)
+print("{0:<30} {1:>10} {2:>10} {3:>15} {4:>10}".format(
+ "Parameter",
+ "Mu_Star",
+ "Mu",
+ "Mu_Star_Conf",
+ "Sigma")
+ )
+for j in list(range(number_of_groups)):
+ print("{0:30} {1:10.3f} {2:10.3f} {3:15.3f} {4:10.3f}".format(
+ Si_OF['names'][j],
+ Si_OF['mu_star'][j],
+ Si_OF['mu'][j],
+ Si_OF['mu_star_conf'][j],
+ Si_OF['sigma'][j]))
+import csv
+line1=Si_OF['mu_star']
+line2=Si_OF['mu_star_conf']
+line3=Si_CumulativeCO2['mu_star']
+line4=Si_CumulativeCO2['mu_star_conf']
+with open('MMResults.csv', 'w') as f:
+ writer = csv.writer(f, delimiter=',')
+ writer.writerow(unique_group_names)
+ writer.writerow('Objective Function')
+ writer.writerow(line1)
+ writer.writerow(line2)
+ writer.writerow("Cumulative CO2 Emissions")
+ writer.writerow(line3)
+ writer.writerow(line4)
+
+f.close
+print("--- %s seconds ---" % (time.time() - start_time))
+
diff --git a/temoa_stochastic/tools/options/README.txt b/temoa_stochastic/tools/options/README.txt
new file mode 100644
index 0000000..91452d7
--- /dev/null
+++ b/temoa_stochastic/tools/options/README.txt
@@ -0,0 +1,67 @@
+Stochastic Temoa Tree Generation Options Files
+==============================================
+
+The options.py files in this directory describe stochastic trees as implemented
+by the generate_scenario_tree.py script in the parent directory. These files
+serve as a command line input to that script, specifying various items necessary
+to create a generic scenario tree stucture and input dot dat files.
+
+The options.py files in this directory will generally be imported via the
+generate_scenario_tree.py script in the parent directory. The script then
+expects to be able to access the below items via the imported file.
+
+If any of the below is not clear, the other files in this directory can serve as
+examples. If you do not have the files, the Temoa repository contains them all
+at http://svn.temoaproject.org/trac/. Check "Browse Source". At the time of
+this writing, the files are located in
+
+branches/stochastic/options/
+
+Elements an options.py Should Specify
+=====================================
+
+(str) dirname (optional)
+ This directory will be where all output files are placed. If not specified,
+ the name of the options file will be used as the default.
+
+(bool) verbose
+ Should the script give information about it's progress?
+
+(bool) force
+ If the dirname already exists, remove it before proceeding?
+
+(path) modelpath
+ Relative or absolute path of where to find the model
+
+(path) dotdatpath
+ Relative or absolute path of where to find the base LP dat file.
+
+(str) stochasticset
+ Within the model, the name of the stochastic set that indexes the parameters
+ to be rate-modified.
+
+(tuple) stochastic_points
+ Within the model, specifically /which/ items in the stochastic set are the
+ stochastic ones? For the parameters specified in types and rates, the ones
+ indexed by these points will be modified. Note that for useful output, this
+ item, if specified, needs at least two stochastic points, and the first one
+ will have a conditional probability of 1.
+
+(dict) stochastic_indices
+ For each parameter to modify, the numerical order of its stochastic index.
+ This is a 0-based, numerical specification.
+
+(tuple of strings) types
+ Each item in this tuple is the name of a decision branch from a node. However
+ many items specified here, are the number of branches each node in the event
+ tree will have.
+
+(dict) conditional_probability
+ This dict specifies the conditional probability of each branch.
+
+(dict of dicts of tuples) rates
+ This is a two-level dict that specifies each parameter to modify, and for each
+ branch in types, what to multiply against each index. Indices can be
+ explicitly spelled-out, or specified in a group via an asterisk.
+
+-----
\ No newline at end of file
diff --git a/temoa_stochastic/tools/options/__init__.py b/temoa_stochastic/tools/options/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/temoa_stochastic/tools/options/stoch_T_0.py b/temoa_stochastic/tools/options/stoch_T_0.py
new file mode 100644
index 0000000..f19b914
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_T_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'T_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/T_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_U_0.py b/temoa_stochastic/tools/options/stoch_U_0.py
new file mode 100644
index 0000000..6ecf60a
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_U_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'U_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/U_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_WA_0.py b/temoa_stochastic/tools/options/stoch_WA_0.py
new file mode 100644
index 0000000..9f72e11
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_WA_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'WA_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/WA_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_WB_0.py b/temoa_stochastic/tools/options/stoch_WB_0.py
new file mode 100644
index 0000000..676dc67
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_WB_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'WB_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/WB_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_WC_0.py b/temoa_stochastic/tools/options/stoch_WC_0.py
new file mode 100644
index 0000000..8497c3a
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_WC_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'WC_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/WC_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_WD_0.py b/temoa_stochastic/tools/options/stoch_WD_0.py
new file mode 100644
index 0000000..9c06a94
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_WD_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'WD_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/WD_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_WE_0.py b/temoa_stochastic/tools/options/stoch_WE_0.py
new file mode 100644
index 0000000..10bd277
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_WE_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'WE_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/WE_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_WF_0.py b/temoa_stochastic/tools/options/stoch_WF_0.py
new file mode 100644
index 0000000..7735064
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_WF_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'WF_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/WF_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_XA_0.py b/temoa_stochastic/tools/options/stoch_XA_0.py
new file mode 100644
index 0000000..99abcbd
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_XA_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'XA_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/XA_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_XB_0.py b/temoa_stochastic/tools/options/stoch_XB_0.py
new file mode 100644
index 0000000..4f52ee8
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_XB_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'XB_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/XB_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_XC_0.py b/temoa_stochastic/tools/options/stoch_XC_0.py
new file mode 100644
index 0000000..edb5eaf
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_XC_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'XC_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/XC_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_XD_0.py b/temoa_stochastic/tools/options/stoch_XD_0.py
new file mode 100644
index 0000000..06dcff5
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_XD_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'XD_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/XD_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_XE_0.py b/temoa_stochastic/tools/options/stoch_XE_0.py
new file mode 100644
index 0000000..437f884
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_XE_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'XE_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/XE_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_XF_0.py b/temoa_stochastic/tools/options/stoch_XF_0.py
new file mode 100644
index 0000000..24d1d08
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_XF_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'XF_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/XF_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_YA_0.py b/temoa_stochastic/tools/options/stoch_YA_0.py
new file mode 100644
index 0000000..885dc75
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_YA_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'YA_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/YA_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_YB_0.py b/temoa_stochastic/tools/options/stoch_YB_0.py
new file mode 100644
index 0000000..fde481a
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_YB_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'YB_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/YB_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_YC_0.py b/temoa_stochastic/tools/options/stoch_YC_0.py
new file mode 100644
index 0000000..9af1730
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_YC_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'YC_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/YC_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_YD_0.py b/temoa_stochastic/tools/options/stoch_YD_0.py
new file mode 100644
index 0000000..0255688
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_YD_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'YD_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/YD_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_YE_0.py b/temoa_stochastic/tools/options/stoch_YE_0.py
new file mode 100644
index 0000000..69bbc37
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_YE_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'YE_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/YE_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_YF_0.py b/temoa_stochastic/tools/options/stoch_YF_0.py
new file mode 100644
index 0000000..f6b299f
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_YF_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'YF_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/YF_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_ZA_0.py b/temoa_stochastic/tools/options/stoch_ZA_0.py
new file mode 100644
index 0000000..f1b1362
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_ZA_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'ZA_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/ZA_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_ZB_0.py b/temoa_stochastic/tools/options/stoch_ZB_0.py
new file mode 100644
index 0000000..2723ace
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_ZB_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'ZB_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/ZB_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_ZC_0.py b/temoa_stochastic/tools/options/stoch_ZC_0.py
new file mode 100644
index 0000000..248d5a0
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_ZC_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'ZC_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/ZC_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_ZD_0.py b/temoa_stochastic/tools/options/stoch_ZD_0.py
new file mode 100644
index 0000000..07c2837
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_ZD_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'ZD_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/ZD_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_ZE_0.py b/temoa_stochastic/tools/options/stoch_ZE_0.py
new file mode 100644
index 0000000..821e01e
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_ZE_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'ZE_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/ZE_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/options/stoch_ZF_0.py b/temoa_stochastic/tools/options/stoch_ZF_0.py
new file mode 100644
index 0000000..6939bbe
--- /dev/null
+++ b/temoa_stochastic/tools/options/stoch_ZF_0.py
@@ -0,0 +1,122 @@
+# Automatically generated stochastic input file from temoatools github.com/EnergyModels/temoatools
+
+verbose = True
+force = True
+
+dirname = 'ZF_0'
+modelpath = '../temoa_model/temoa_model.py'
+dotdatpath = '../data_files/ZF_0.dat'
+stochasticset = 'time_optimize'
+stochastic_points = (2016, 2021, 2026, 2031, 2036, )
+stochastic_indices = {'CapReduction': 0}
+types = (
+ 'H1', 'H2', 'H3',
+)
+conditional_probability = dict(
+ H1=0.52,
+ H2=0.32,
+ H3=0.16,
+)
+rates = {
+ 'CapReduction': dict(
+ H1=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 1.0),
+ ('EC_BATT', 0.998),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 1.0),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.998),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 1.0),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.998),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 1.0),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 1.0),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 1.0),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 1.0),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H2=(
+ ('EX_DSL_CC', 1.0),
+ ('SUB', 0.999),
+ ('EC_BATT', 0.989),
+ ('EX_SOLPV', 1.0),
+ ('DIST_COND', 0.666),
+ ('EX_COAL', 1.0),
+ ('EX_HYDRO', 0.989),
+ ('EX_MSW_LF', 1.0),
+ ('TRANS', 0.967),
+ ('ED_NG_OC', 1.0),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 1.0),
+ ('ED_NG_CC', 1.0),
+ ('ED_BATT', 0.989),
+ ('EC_NG_CC', 1.0),
+ ('EX_OIL_TYPE3', 1.0),
+ ('EX_OIL_TYPE2', 1.0),
+ ('EC_WIND', 0.985),
+ ('EC_SOLPV', 1.0),
+ ('UGND_TRANS', 1.0),
+ ('EX_WIND', 0.985),
+ ('EX_NG_CC', 1.0),
+ ('EC_NG_OC', 1.0),
+ ('ED_WIND', 0.985),
+ ('UGND_DIST', 1.0),
+ ('DIST_TWR', 0.739),
+ ('EC_BIO', 1.0),
+ ('ED_BIO', 1.0),
+ ('ED_SOLPV', 1.0),
+ ('EX_OIL_TYPE1', 1.0),
+ ),
+
+ H3=(
+ ('EX_DSL_CC', 0.913),
+ ('SUB', 0.785),
+ ('EC_BATT', 0.554),
+ ('EX_SOLPV', 0.602),
+ ('DIST_COND', 0.05),
+ ('EX_COAL', 0.573),
+ ('EX_HYDRO', 0.582),
+ ('EX_MSW_LF', 0.913),
+ ('TRANS', 0.739),
+ ('ED_NG_OC', 0.913),
+ ('LOCAL', 1.0),
+ ('EX_DSL_SIMP', 0.913),
+ ('ED_NG_CC', 0.913),
+ ('ED_BATT', 0.554),
+ ('EC_NG_CC', 0.913),
+ ('EX_OIL_TYPE3', 0.913),
+ ('EX_OIL_TYPE2', 0.913),
+ ('EC_WIND', 0.201),
+ ('EC_SOLPV', 0.602),
+ ('UGND_TRANS', 0.913),
+ ('EX_WIND', 0.201),
+ ('EX_NG_CC', 0.913),
+ ('EC_NG_OC', 0.913),
+ ('ED_WIND', 0.201),
+ ('UGND_DIST', 0.913),
+ ('DIST_TWR', 0.177),
+ ('EC_BIO', 0.573),
+ ('ED_BIO', 0.573),
+ ('ED_SOLPV', 0.602),
+ ('EX_OIL_TYPE1', 0.913),
+ ),
+
+ ),
+}
diff --git a/temoa_stochastic/tools/rewrite_tree_nodes.py b/temoa_stochastic/tools/rewrite_tree_nodes.py
new file mode 100644
index 0000000..2446a78
--- /dev/null
+++ b/temoa_stochastic/tools/rewrite_tree_nodes.py
@@ -0,0 +1,104 @@
+
+import os
+import sys
+from os.path import isfile, join
+import pandas as pd
+
+#directory = "C:\\temoa_stochastic2\\tools\\WA_0"
+#directory = dirname
+
+
+from os import getcwd
+from os.path import abspath, basename, dirname
+from time import clock
+
+if len(sys.argv) < 2:
+ usage()
+module_name = sys.argv[1][:-3].replace('/', '.') # remove the '.py'
+
+mbase = basename( module_name )[:-3]
+mdir = abspath( dirname( module_name ))
+sys.path.insert(0, mdir)
+
+try:
+ __import__(module_name)
+ opts = sys.modules[ module_name ]
+ sys.path.pop(0)
+except ImportError:
+ msg = ('Unable to import {}.\n\nRun this script with no arguments for '
+ 'more information.\n')
+ SE.write( msg.format( sys.argv[1] ) )
+ raise
+
+
+# Create dataframe to hold probabilities
+cols = []
+for types in opts.types:
+ cols.append(types)
+df_rates = pd.DataFrame(columns=cols)
+for key in opts.rates['CapReduction'].keys():
+ for pair in opts.rates['CapReduction'][key]:
+ df_rates.loc[pair[0],key]=pair[1]
+
+# Move to directory
+print(os.getcwd())
+wrkdir = os.getcwd()
+os.chdir(opts.dirname)
+dirname = os.getcwd()
+
+# Iterate through Directory
+for fname in os.listdir(dirname):
+ # Check if it is a file
+ if isfile(join(dirname,fname)):
+ #print(fname)
+
+ # Check if it is a node file
+ if fname[0:2]=='Rs':
+
+ # Determine previous nodes based on file naming convention
+ events = []
+ ind1 = fname.find('.dat')
+ fname2 = fname[0:ind1]
+ ind2 = 2
+ events.append(opts.types[int(fname2[ind2])])
+
+ while ind2