def explore_Cost_marginal(dat): from temoa_model import temoa_create_model model = temoa_create_model() model.dual = Suffix(direction=Suffix.IMPORT) model.rc = Suffix(direction=Suffix.IMPORT) model.slack = Suffix(direction=Suffix.IMPORT) model.lrc = Suffix(direction=Suffix.IMPORT) model.urc = Suffix(direction=Suffix.IMPORT) data = DataPortal(model=model) for d in dat: data.load(filename=d) instance = model.create_instance(data) # Deactivate the DemandActivity constraint # instance.DemandActivityConstraint.deactivate() # instance.preprocess() optimizer = SolverFactory('cplex') results = optimizer.solve(instance, keepfiles=True, suffixes=['dual', 'urc', 'slack', 'lrc']) instance.solutions.load_from(results) print 'Dual and slack variables for emission caps:' for e in instance.commodity_emissions: for p in instance.time_optimize: if (p, e) in instance.EmissionLimitConstraint: print p, e, instance.dual[instance.EmissionLimitConstraint[ p, e]], '\t', instance.slack[ instance.EmissionLimitConstraint[p, e]]
def return_Temoa_model(): from temoa_model import temoa_create_model model = temoa_create_model() model.dual = Suffix(direction=Suffix.IMPORT) model.rc = Suffix(direction=Suffix.IMPORT) model.slack = Suffix(direction=Suffix.IMPORT) model.lrc = Suffix(direction=Suffix.IMPORT) model.urc = Suffix(direction=Suffix.IMPORT) return model
ef_instance.solutions.store_to(ef_result) ef_obj = value(ef_instance.EF_EXPECTED_COST.values()[0]) return ef_obj def StochasticPointObjective_rule(M, p): expr = (M.StochasticPointCost[p] == PeriodCost_rule(M, p)) return expr def Objective_rule(M): return sum(M.StochasticPointCost[pp] for pp in M.time_optimize) M = model = temoa_create_model('TEMOA Stochastic') M.StochasticPointCost = Var(M.time_optimize, within=NonNegativeReals) M.StochasticPointCostConstraint = Constraint( M.time_optimize, rule=StochasticPointObjective_rule) del M.TotalCost M.TotalCost = Objective(rule=Objective_rule, sense=minimize) if __name__ == "__main__": p_model = "./ReferenceModel.py" temoa_options, config_flag = parse_args() p_dot_dat = temoa_options.dot_dat[0] # must be ScenarioStructure.dat p_data = os.path.dirname(p_dot_dat) print(p_model, p_data) print(solve_ef(p_model, p_data, temoa_options))
def sensitivity(dat, techs): # This function performs break-even analysis for technologies specified in # the argument techs. It uses suffix from Pyomo and returns the breakeven # cost as screen outputs. Note that the Pyomo suffix sometimes returns # anomalous values, and that's why I create another function, # sensitivity_api() to use Python API for CPLEX. from temoa_model import temoa_create_model model = temoa_create_model() model.dual = Suffix(direction=Suffix.IMPORT) model.rc = Suffix(direction=Suffix.IMPORT) model.slack = Suffix(direction=Suffix.IMPORT) model.lrc = Suffix(direction=Suffix.IMPORT) model.urc = Suffix(direction=Suffix.IMPORT) data = DataPortal(model=model) for d in dat: data.load(filename=d) instance = model.create_instance(data) optimizer = SolverFactory('cplex') optimizer.options['lpmethod'] = 1 # Use primal simplex results = optimizer.solve(instance, suffixes=['dual', 'urc', 'slack', 'lrc']) instance.solutions.load_from(results) coef_CAP = dict() scal_CAP = dict() # Break-even investment cost for this scenario, indexed by technology years = list() bic_s = dict() ic_s = dict() # Raw investment costs for this scenario, indexed by tech cap_s = dict() for t in techs: vintages = instance.vintage_optimize P_0 = min(instance.time_optimize) GDR = value(instance.GlobalDiscountRate) MLL = instance.ModelLoanLife MPL = instance.ModelProcessLife LLN = instance.LifetimeLoanProcess x = 1 + GDR # convenience variable, nothing more. bic_s[t] = list() ic_s[t] = list() cap_s[t] = list() years = vintages.value for v in vintages: period_available = set() for p in instance.time_future: if (p, t, v) in instance.CostFixed.keys(): period_available.add(p) c_i = (instance.CostInvest[t, v] * instance.LoanAnnualize[t, v] * (LLN[t, v] if not GDR else (x**(P_0 - v + 1) * (1 - x**(-value(LLN[t, v]))) / GDR))) c_s = (-1) * (value(instance.CostInvest[t, v]) * value(instance.SalvageRate[t, v]) / (1 if not GDR else (1 + GDR)**(instance.time_future.last() - instance.time_future.first() - 1))) c_f = sum(instance.CostFixed[p, t, v] * (MPL[p, t, v] if not GDR else (x**(P_0 - p + 1) * (1 - x**(-value(MPL[p, t, v]))) / GDR)) for p in period_available) c = c_i + c_s + c_f s = (c - instance.lrc[instance.V_Capacity[t, v]]) / c coef_CAP[t, v] = c scal_CAP[t, v] = s # Must reduce TO this percentage bic_s[t].append(scal_CAP[t, v] * instance.CostInvest[t, v]) ic_s[t].append(instance.CostInvest[t, v]) cap_s[t].append(value(instance.V_Capacity[t, v])) # print "Tech\tVintage\tL. RC\tCoef\tU .RC\tScale\tBE IC\tBE FC\tIC\tFC\tCap" print "{:>10s}\t{:>7s}\t{:>6s}\t{:>4s}\t{:>6s}\t{:>5s}\t{:>7s}\t{:>7s}\t{:>5s}\t{:>3s}\t{:>5s}".format( 'Tech', 'Vintage', 'L. RC', 'Coef', 'U. RC', 'Scale', 'BE IC', 'BE FC', 'IC', 'FC', 'Cap') for v in vintages: lrc = instance.lrc[instance.V_Capacity[t, v]] urc = instance.urc[instance.V_Capacity[t, v]] # print "{:>s}\t{:>g}\t{:>.0f}\t{:>.0f}\t{:>.0f}\t{:>.3f}\t{:>.1f}\t{:>.1f}\t{:>.0f}\t{:>.0f}\t{:>.3f}".format( print "{:>10s}\t{:>7g}\t{:>6.0f}\t{:>4.0f}\t{:>6.0f}\t{:>5.3f}\t{:>7.1f}\t{:>7.1f}\t{:>5.0f}\t{:>3.0f}\t{:>5.3f}".format( t, v, lrc, coef_CAP[t, v], urc, scal_CAP[t, v], scal_CAP[t, v] * instance.CostInvest[t, v], scal_CAP[t, v] * instance.CostFixed[v, t, v], # Use the FC of the first period instance.CostInvest[t, v], instance.CostFixed[v, t, v], value(instance.V_Capacity[t, v])) print 'Dual and slack variables for emission caps:' for e in instance.commodity_emissions: for p in instance.time_optimize: if (p, e) in instance.EmissionLimitConstraint: print p, e, instance.dual[instance.EmissionLimitConstraint[ p, e]], '\t', instance.slack[ instance.EmissionLimitConstraint[p, e]] return years, bic_s, ic_s print 'Dual and slack variables for Commodity Demand Constraints' for c in instance.commodity_demand: for p in instance.time_optimize: for s in instance.time_season: for tod in instance.time_of_day: print p, s, tod, instance.dual[instance.DemandConstraint[ p, s, tod, c]], instance.slack[instance.DemandConstraint[p, s, tod, c]]
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 <http://www.gnu.org/licenses/>. """ from temoa_lib import Var, Objective, Constraint, NonNegativeReals, minimize from temoa_model import temoa_create_model from temoa_rules import PeriodCost_rule def StochasticPointObjective_rule ( M, p ): expr = ( M.StochasticPointCost[ p ] == PeriodCost_rule( M, p ) ) return expr def Objective_rule ( M ): return sum( M.StochasticPointCost[ pp ] for pp in M.time_optimize ) M = model = temoa_create_model( 'TEMOA Stochastic' ) M.StochasticPointCost = Var( M.time_optimize, within=NonNegativeReals ) M.StochasticPointCostConstraint = Constraint( M.time_optimize, rule=StochasticPointObjective_rule ) del M.TotalCost M.TotalCost = Objective( rule=Objective_rule, sense=minimize )
# The Prices are the duals of the DemandConstraint constraints. # The search range for the variable V_Demand, (MinDemand, MaxDemand) # is determined using DEMAND_RANGE. The Price, MinDemand and MaxDemand # are written to the file, price.dat. # Usage: same as temoa_model.py. # Addition output: writes file price.dat in the current directory. DEMAND_RANGE = 0.3 # Max/MinDemand = (1 +/- DEMAND_RANGE)* Demand DEMAND_SEGMENTS = 27 # Keep this an odd number to reproduce fixed demand results! from temoa_model import temoa_create_model, temoa_create_model_container from temoa_lib import temoa_solve import sys model = temoa_create_model() model_data = temoa_create_model_container(model) temoa_solve(model_data) instance = model_data.instance price_data = open("price.dat", "w") ConstantDemandConstraint = instance.DemandConstraint Demand = instance.Demand print >> price_data, """\ data; param: MinDemand MaxDemand := # year # min # max """