entrega de cÓdigo fuente del algoritmo usado para la ... · medellín, 28 de noviembre de 2019...

ENTREGA DE CÓDIGO FUENTE DEL ALGORITMO USADO PARA LA SEGUNDA SUBASTA DE CLPE

NOVIEMBRE - 2019

Medellín, 28 de noviembre de 2019 Ingeniero RICARDO RAMÍREZ CARRERO Director UPME Asunto: Entrega código fuente algoritmo segunda subasta CLPE Estimado Ingeniero Ramirez,

En el presente documento se hace la entrega del código fuente del algoritmo desarrollado por Rightside para la segunda subasta de CLPE en Colombia. La versión descrita corresponde a la

ejecutada el día 22 de octubre de 2019, día en que fue realizada la adjudicación.

Quedamos atentos a cualquier inquietud que pueda surgir con el código.

Cordialmente, __________________________ Oscar Mauricio Carreño Rincón Representante Legal RIGHTSIDE S.A.S

[email protected] Carrera 48ª # 16 sur – 86 piso 6 MEDELLÍN-COLOMBIA

CÓDIGO ARCHIVO DATOSENTRADA.PY

# --------------------------------------------------------

# MODELO SUBASTA CLPE

# DESARROLLADO PARA LA UPME Y EL MME

# Rightside SAS - 2019 - www.rightside.app

# --------------------------------------------------------

import pandas as pd

from pandasql import sqldf

import datetime

from os import getcwd

from openpyxl import load_workbook

import pyodbc

conn = pyodbc.connect('Driver={SQL Server};'

'Server=localhost\SQLEXPRESS;'

'Database=Subasta;'

'Trusted_Connection=yes;')

cursor = conn.cursor()

sqlp1 = 'SELECT [IdParametroSubasta],[DemandaObjetivo],[TopeMaximoPromedio],[TopeMaximoIndiv

idual],[TamanoPaquete]*1000 [TamanoPaquete] FROM [Subasta].[dbo].[ParametrosSubasta]'

for row in cursor.execute(sqlp1):

paqueteKWH=(row.TamanoPaquete)

PRECIOTOPE=(row.TopeMaximoPromedio)

PRECIOMAXIMO=(row.TopeMaximoIndividual)

DEMANDAOBJETIVO=(row.DemandaObjetivo)

optimizador = 'gams'

tolerancia = 0.000001

toleranciaABS = 1

tiempoLimite = 10000

sql1='SELECT rtrim([nombre]) [nombre],rtrim([ID_oferta]) [ID_oferta],[energiaMax] energiaMax_

MWh_d,[precio] precio_COP_kWh,[ordenllegada] ordenLlegada,[Sobre],[Proceso],[energiaMin] ener

giaMinima FROM [dbo].[ofertasCompra] where sobre=2'

sql2='SELECT rtrim([nombre]) [nombre],rtrim([ID_oferta]) [ID_oferta] , rtrim([bloque]) [bloq

ue],[numPaquetesMax],[numPaquetesMin],[precio] precio_COP_kWh,rtrim([simultanea]) [simultanea


],rtrim([excluyente]) [excluyente],rtrim([dependiente]) [dependiente],[ordenllegada] ordenLle

gada,[Sobre],[Proceso],0 [obligatorio] FROM [dbo].[ofertasVenta] where sobre=2'

sql3='SELECT rtrim([nombre]) [nombre],rtrim([empresa]) [empresa] ,[energiaMaximaGarantizada],

[Proceso] FROM [dbo].[proyectosGeneracion]'

sql4='SELECT rtrim([bloques]) [bloques],[pi],[pf] FROM [dbo].[bloques]'

ofertasCompra = pd.read_sql(sql1, conn).set_index(['ID_oferta'])

ofertasVenta = pd.read_sql(sql2, conn).set_index(['ID_oferta','bloque'])

proyectosVenta= pd.read_sql(sql2, conn).set_index(['nombre','ID_oferta'])

proyectosCompra = pd.read_sql(sql1, conn).set_index(['nombre','ID_oferta'])

proyectosGeneracion = pd.read_sql(sql3, conn).set_index(['nombre'])

Bloques = pd.read_sql(sql4, conn).set_index(['bloques'])

conn.close()

#LECTURA DE INDICES;

Comercializadores = sqldf("SELECT distinct(nombre) FROM ofertasCompra WHERE nombre <> ' ' OR

DER BY nombre;", locals())

Generadores = sqldf("SELECT distinct(nombre) FROM proyectosGeneracion WHERE nombre <> ' ' OR

DER BY nombre;", locals())

Empresas = sqldf("SELECT distinct(empresa) FROM proyectosGeneracion;", locals())

bloques = sqldf("SELECT distinct(bloques) FROM Bloques;", locals())

id_c = sqldf("SELECT distinct(ID_oferta) FROM ofertasCompra;", locals())

id_v = sqldf("SELECT distinct(ID_oferta) FROM ofertasVenta;", locals())


CÓDIGO ARCHIVO SUBASTACLPE.PY

# ___________________________________________________________________________

#

# Pyomo: Python Optimization Modeling Objects

# Copyright 2017 National Technology and Engineering Solutions of Sandia, LLC

# Under the terms of Contract DE-NA0003525 with National Technology and

# Engineering Solutions of Sandia, LLC, the U.S. Government retains certain

# rights in this software.

# This software is distributed under the 3-clause BSD License.

# ___________________________________________________________________________

# --------------------------------------------------------

# MODELO SUBASTA CLPE

# DESARROLLADO PARA LA UPME Y EL Ministerio de Minas y Energia

# Oscar Carreno - Rightside SAS - 2019 - www.rightside.app

# --------------------------------------------------------

from pyomo.environ import *

from pyomo.opt import SolverFactory , SolverStatus, TerminationCondition

from pyomo.core import Constraint

from pyomo.opt import ProblemFormat

from pandas import ExcelWriter

from pandas import ExcelFile

import pandas as pd

from openpyxl import load_workbook

from DatosEntrada import *

import linecache

import sys

import math

import pyodbc

conn = pyodbc.connect('Driver={SQL Server};'

'Server=localhost\SQLEXPRESS;'

'Database=Subasta;'

'Trusted_Connection=yes;')

cursor = conn.cursor()

print ()

print(" EJECUTANDO MODELO DE SUBASTA CLPE Version 5.3 - Version Definitiva")

print ()

def PrintException():

exc_type, exc_obj, tb = sys.exc_info()

f = tb.tb_frame


lineno = tb.tb_lineno

filename = f.f_code.co_filename

linecache.checkcache(filename)

line = linecache.getline(filename, lineno, f.f_globals)

print ('SE ENCONTRo UN ERROR ({}, LINE {} "{}"): {}'.format(filename, lineno, line.strip(

), exc_obj))

def truncate(number, digits) -> float:

stepper = 10.0 ** digits

return math.trunc(stepper * number) / stepper

segundoMecanismo = 1

PRECIOCOMPRA = {}

PRECIOVENTA = {}

MAXCOMPRA = {}

MAXVENTA = {}

MINVENTA ={}

DURACION = {}

BLOQUEOFERTAV = {}

POTENCIAMAXV_KWH = {}

ENERGIAMAXV_KWH = {}

sumMAXCOMPRA = 0

sumVENTA = 0

CRITERIOCOMPETENCIA = {}

ENERGIAMAXV_KWH_CC = {}

ENERGIAMAXV_KWH_TOTAL = 0

ID_G = {}

ID_B = {}

ID_C = {}

PRECIOCOMPRA_DESEMPATADO = {}

PRECIOVENTA_DESEMPATADO = {}

MINPRECIOVENTA = 0

ASIGNACION_COMPRA = {}

ASIGNACION_VENTA = {}

BINARIAS_VENTA = {}

DEMANDA_MINIMA = {}

ENERGIA_GARANTIZADA = {}

OFE_GEN = {}

try:

while segundoMecanismo >= 1:

clpe = ConcreteModel()

clpe.COMERCIALIZADORES = Set(initialize=Comercializadores.nombre, ordered = True)


clpe.GENERADORES = Set(initialize=Generadores.nombre, ordered = True)

clpe.EMPRESAS = Set(initialize=Empresas.empresa, ordered = True)

clpe.BLOQUES = Set(initialize=bloques.bloques, ordered = True)

clpe.ID_C = Set(initialize=id_c.ID_oferta, ordered = True)

clpe.ID_V = Set(initialize=id_v.ID_oferta, ordered = True)

clpe.NOMBRE_ID_VENTA = Set(clpe.GENERADORES)

for b in Bloques.index:

DURACION[b] = 1 + Bloques.pf[b] - Bloques.pi[b]

for p in proyectosVenta.index:

clpe.NOMBRE_ID_VENTA[p[0]].add(p[1])

ID_G[p[1]] = p[0]

for p in proyectosCompra.index:

ID_C[p[1]] = p[0]

for c in clpe.COMERCIALIZADORES:

DEMANDA_MINIMA [c] = 0

if segundoMecanismo == 1:

ASIGNACION_COMPRA[c] = 0

for c in ofertasCompra.index:

PRECIOCOMPRA[c] = 0

MAXCOMPRA[c] = 0


PRECIOCOMPRA[c] = ofertasCompra.precio_COP_kWh[c]

if str(ofertasCompra.precio_COP_kWh[c]) == 'nan': PRECIOCOMPRA[c] = 0

MAXCOMPRA[c] = ofertasCompra.energiaMax_MWh_d[c]*1000

sumMAXCOMPRA=sumMAXCOMPRA + MAXCOMPRA[c]

DEMANDA_MINIMA [ofertasCompra.nombre[c]] = ofertasCompra.energiaMinima[c]*1000

for i in clpe.ID_V:

for b in clpe.BLOQUES:

PRECIOVENTA[i] = 0


ASIGNACION_VENTA[i] = 0

BINARIAS_VENTA[i] = 0

for v in ofertasVenta.index:

MAXVENTA[v] = 0

MINVENTA[v] = 0

ID_B[v[0]] = v[1]


for g in proyectosGeneracion.index:

ENERGIA_GARANTIZADA[g] = proyectosGeneracion.energiaMaximaGarantizada[g]

OFE_GEN[g] = 0



if v[0] in clpe.NOMBRE_ID_VENTA[g]:

OFE_GEN[g] = 1


PRECIOVENTA[v[0]] = ofertasVenta.precio_COP_kWh[v]

MAXVENTA[v] = ofertasVenta.numPaquetesMax[v]*paqueteKWH*DURACION[v[1]]

MINVENTA[v] = ofertasVenta.numPaquetesMin[v]*paqueteKWH*DURACION[v[1]]

BLOQUEOFERTAV[v[0]] = v[1]

for e in clpe.EMPRESAS:

ENERGIAMAXV_KWH_CC[e] = 0

CRITERIOCOMPETENCIA[e] = 0


PRECIOCOMPRA_DESEMPATADO[c] = PRECIOCOMPRA[c]



if PRECIOCOMPRA[c] == PRECIOVENTA[v[0]]:

PRECIOCOMPRA_DESEMPATADO[c] = PRECIOCOMPRA[c] + 0.001

empatadosVenta = set()

unicoVenta = set()


PRECIOVENTA_DESEMPATADO[v[0]] = PRECIOVENTA[v[0]]


if PRECIOVENTA[v[0]] not in unicoVenta:

unicoVenta.add(PRECIOVENTA[v[0]])

else:

empatadosVenta.add(PRECIOVENTA[v[0]])


if PRECIOVENTA[v[0]] in empatadosVenta:

PRECIOVENTA_DESEMPATADO[v[0]] = PRECIOVENTA[v[0]] + ofertasVenta.ordenLlegada

[v]/100000

empatadosCompra = set()


unicoCompra = set()


if PRECIOCOMPRA[c] not in unicoCompra:

unicoCompra.add(PRECIOCOMPRA[c])

else:

empatadosCompra.add(PRECIOCOMPRA[c])


if PRECIOCOMPRA[c] in empatadosCompra:

PRECIOCOMPRA_DESEMPATADO[c] = PRECIOCOMPRA_DESEMPATADO[c] - ofertasCompra.ord

enLlegada[c]/100000


repetidoComercializador = set()

unicoComercializador = set()

contRepetido = {}

for c in proyectosCompra.index:

contRepetido[c[0]] = 0

if c[0] not in unicoComercializador:

unicoComercializador.add(c[0])

else:

repetidoComercializador.add(c[0])

for c in proyectosCompra.index:

PRECIOCOMPRA_DESEMPATADO[c[1]] = PRECIOMAXIMO

PRECIOCOMPRA[c[1]] = PRECIOMAXIMO

if ASIGNACION_COMPRA[c[0]] == 0:

if c[0] in repetidoComercializador:

MAXCOMPRA[c[1]] = 0

else:

MAXCOMPRA[c[1]] = DEMANDA_MINIMA[c[0]]

else:

if ASIGNACION_COMPRA[c[0]] >= DEMANDA_MINIMA[c[0]]:

MAXCOMPRA[c[1]] = 0

else:

if c[0] in repetidoComercializador:

contRepetido[c[0]] += 1

if contRepetido[c[0]] == 1:

MAXCOMPRA[c[1]] = DEMANDA_MINIMA[c[0]] - ASIGNACION_COMPRA[c[

0]]

else:

MAXCOMPRA[c[1]] = 0

else:

MAXCOMPRA[c[1]] = DEMANDA_MINIMA[c[0]] - ASIGNACION_COMPRA[c[0]]



MAXVENTA[v] = MAXVENTA[v] - ASIGNACION_VENTA[v[0]]

if ASIGNACION_VENTA[v[0]] > 0: MINVENTA[v] = 0

sumMAXCOMPRA = 0


sumMAXCOMPRA = sumMAXCOMPRA + MAXCOMPRA[c]


if PRECIOCOMPRA[c] == PRECIOVENTA[v[0]]:

PRECIOCOMPRA_DESEMPATADO[c] = PRECIOCOMPRA[c] + 0.001

porcentajeComercializadorMC = {}

if sumMAXCOMPRA < DEMANDAOBJETIVO*1000:


porcentajeComercializadorMC[c] = MAXCOMPRA[c]/sumMAXCOMPRA

MAXCOMPRA[c] = porcentajeComercializadorMC[c]*DEMANDAOBJETIVO*1000

# **************** INICIA MODELO MATEMaTICO ****************

# Variables enteras

clpe.asignacionV = Var(clpe.ID_V,domain=NonNegativeIntegers)

clpe.asignacionC = Var(clpe.ID_C,domain=NonNegativeIntegers)

clpe.binaria = Var(clpe.ID_V,domain=Boolean)

clpe.binariaC = Var(clpe.ID_C,domain=Boolean)

#------------------------------

# FUNCION OBJETIVO

#------------------------------

print ()

print(" MAXIMIZACIoN DE BENEFICIO CONSUMIDOR")

print ()

def Excedente_rule(clpe):

expr = sum (PRECIOCOMPRA_DESEMPATADO[c]*clpe.asignacionC[c]

for c in ofertasCompra.index)

expr -= sum ( PRECIOVENTA_DESEMPATADO[v[0]]*clpe.asignacionV[v[0]]

for v in ofertasVenta.index )

return expr

clpe.FuncionObjetivo = Objective(rule=Excedente_rule, sense=maximize)

# RESTRICCIONES DEL MODELO MATEMaTICO

# ********* Restriccion de balance

clpe.r0_balance = ConstraintList()

clpe.r0_balance.add (

sum (clpe.asignacionC[c]

for c in ofertasCompra.index )


== sum (clpe.asignacionV[v[0]]

for v in ofertasVenta.index)

)

# Restricciones para el segundo mecanismo


clpe.r_balanceSegundoMecanismo = ConstraintList()

clpe.r_balanceSegundoMecanismo.add (

sum (clpe.asignacionV[v[0]]

for v in ofertasVenta.index) <= DEMANDAOBJETIVO*1000

)

clpe.r_binariasSegundoMecanismo = ConstraintList()


if ASIGNACION_VENTA[v[0]] > 0:

clpe.r_binariasSegundoMecanismo.add (

clpe.binaria[v[0]] == 1

)

# ********* Restriccion de maximo compra


clpe.r1_maxCompra = ConstraintList()


clpe.r1_maxCompra.add ( clpe.asignacionC[c] <= MAXCOMPRA[c]*clpe.binariaC[c]

)

# ********* Restriccion de maximo venta potencia y

clpe.r2_maxVenta = ConstraintList()

clpe.r2_binMax = ConstraintList()


if PRECIOVENTA[v[0]] > PRECIOMAXIMO:

clpe.r2_maxVenta.add ( clpe.asignacionV[v[0]] == 0 )

clpe.r2_binMax.add ( clpe.binaria[v[0]] == 0 )

else:

clpe.r2_maxVenta.add ( clpe.asignacionV[v[0]] <= MAXVENTA[v]*clpe.binaria[v[0

]] )

# ********* Restriccion de maxima energia garantizada

clpe.r3_maxVentaEnergia = ConstraintList()


if OFE_GEN[g] > 0:

clpe.r3_maxVentaEnergia.add (

sum ( clpe.asignacionV[v[0]]

for v in ofertasVenta.index

if v[0] in clpe.NOMBRE_ID_VENTA[g] ) <= ENERGIA_GARANTIZADA[g]

)


# ********* Restriccion de minimo venta

clpe.r4_minVenta = ConstraintList()


clpe.r4_minVenta.add (

clpe.asignacionV[v[0]] >= MINVENTA[v]*clpe.binaria[v[0]] )

clpe.r4_obligatorio = ConstraintList()


if ofertasVenta.obligatorio[v] == 1:

clpe.r4_obligatorio.add ( clpe.binaria[v[0]] == 1 )

printclpe.binaria[v[0]]


clpe.r5_precioPonderado = ConstraintList()


clpe.r5_precioPonderado.add (

PRECIOCOMPRA[c]*sum (clpe.asignacionV[v[0]]


+ 9999999999*(1-

clpe.binariaC[c]) >= sum (PRECIOVENTA[v[0]] * clpe.asignacionV[v[0]]


)

# ********* Control de ofertas dependientes

clpe.r6_bindependiente = ConstraintList()


if (ofertasVenta.dependiente[v]) is not None:

clpe.r6_bindependiente.add (

clpe.binaria[v[0]] <= clpe.binaria[ofertasVenta.dependiente[v]]

)

# ********* Control de ofertas excluyentes

clpe.r7_binexcluyente = ConstraintList()


if (ofertasVenta.excluyente[v]) is not None:

clpe.r7_binexcluyente.add (

clpe.binaria[v[0]] <= 1 - clpe.binaria[ofertasVenta.excluyente[v]]

)

# ********* Control de ofertas simultaneas

clpe.r8_binsimultanea = ConstraintList()


if (ofertasVenta.simultanea[v]) is not None:

clpe.r8_binsimultanea.add (

clpe.binaria[v[0]] == clpe.binaria[ofertasVenta.simultanea[v]]


)

# ********* Restriccion para garantizar precio ponderado de

clpe.r9_precioPonderadoTope = ConstraintList()

clpe.r9_precioPonderadoTope.add (

sum ( (PRECIOTOPE - PRECIOVENTA[v[0]] ) * clpe.asignacionV[v[0]]

for v in ofertasVenta.index ) >= 0

)

#------------------------------

# EJECUTAR EL MODELO

#------------------------------

opt = SolverFactory(optimizador)

if optimizador == 'cbc':

opt.options['ratioGap'] = tolerancia

opt.options['allowableGap'] = toleranciaABS

opt.options['sec'] = tiempoLimite

if optimizador == 'cplex':

opt.options['mipgap'] = tolerancia

opt.options['mip_tolerances_absmipgap'] = toleranciaABS

opt.options['timelimit'] = tiempoLimite

clpe.write("clpe" + str(segundoMecanismo) + ".lp",io_options={"symbolic_solver_labels

":True})

print ()

if optimizador == 'gams':

print("Ejecutando con optimizador " , optimizador)

print ()

results = opt.solve(clpe,tee=1,solver='cplex',logfile ="clpeMIP" + str(segundoMec

anismo) + ".log", keepfiles= 0,symbolic_solver_labels=True)

else:

print("Optimizador: " , opt.name)

results = opt.solve(clpe,tee=1,logfile ="clpeMIP" + str(segundoMecanismo) + ".log

", keepfiles= 0,symbolic_solver_labels=True)

print ()

if (results.solver.status == SolverStatus.ok) and (results.solver.termination_conditi

on == TerminationCondition.optimal):

print ()

print ()


print(" ----- SE ENCONTRo SOLUCIoN oPTIMA ------")

print ()

print ("Funcion Objetivo PROBLEMA ENTERO: ", float(value(clpe.FuncionObjetivo)))

print ()

#------------------------------

# ESCRIBIR RESULTADOS

#------------------------------

print ("ESCRIBIENDO RESULTADOS EN LA BASE DE DATOS: ")

print ()

funcionObjetivo = 0

funcionObjetivo = round(value(clpe.FuncionObjetivo),2)

ofertasCompraOrder = ofertasCompra.sort_values(by=['precio_COP_kWh','ID_oferta','

ordenLlegada'],ascending=[False,True,True])

ofertasVentaOrder = ofertasVenta.sort_values(by=['precio_COP_kWh','ID_oferta','or

denLlegada'])


procesobd = 'Subasta'

else:

procesobd = 'Mecanismo'

if (procesobd =='Subasta'):

sqlborrar1='DELETE FROM [dbo].[ofertasCompraSalida]'

cursor.execute(sqlborrar1)

sqlborrar2='DELETE FROM [dbo].[ofertasVentaSalida]'


sqlborrar3='DELETE FROM [dbo].[ComprasVentasSalida]'


sqlborrar4='DELETE FROM [dbo].[resumenResultadosSubasta]'


sqlborrar5='DELETE FROM [dbo].[ContratosASIC]'


sqlborrar6='DELETE FROM [dbo].[asignaciones]'


conn.commit()

Concepto="'LA FUNCIoN OBJETIVO ES [$] ='"

InstruccionInsert='exec [dbo].[GrabarresumenResultadosPython] ' + Concepto + ",'"

+ str(funcionObjetivo) + "','" + procesobd + "'"

cursor.execute(InstruccionInsert)

Mensaje1='TOTAL ASIGNADO \n VENTA kWh-bloque'

Mensaje2='% ASIGNACIoN'


Concepto="'BLOQUE'"


+ str(Mensaje1) + " " + str(Mensaje2) + "','" + procesobd + "'"


columnasAsignacionV = ["GENERADOR","ID_OFE","BLOQUE","ENERGIA_MAX (kWh-

b)","ENERGIA_MIN (kWh-b)","PRECIO (COP/kWh)","DESEMPATE (COP/kWh)","SIMULTaNEA",

"EXCLUYENTE","DEPENDIENTE","ASIGNACIoN (kWh-

b)","PORCENTAJE ASIGNACIoN %"]

columnasAsignacionC = ["COMERCIALIZADOR","ID_OFE","PRECIO (COP/kWh)","DESEMPATE (

COP/kWh)","ENERGIA_MAX_DIA (kWh-d)","ASIGNACIoN (kWh-d)","PORCENTAJE ASIGNACIoN %"]

columnasAsignacionContratos = ["VENDEDOR","ID_OFE","BLOQUE"]

columnasAsignacionContratosSIC = ["COMPRADOR","VENDEDOR","CONCEPTO"]

for p in range(1,25):

columnasAsignacionContratosSIC.append(p)

for c in ofertasCompraOrder.index:

columnasAsignacionContratos.append(ID_C[c])

out_asignacionVenta = pd.DataFrame(columns=columnasAsignacionV)

out_asignacionCompra = pd.DataFrame(columns=columnasAsignacionC)

out_asignacionContratos = pd.DataFrame(columns=columnasAsignacionContratos)

out_asignacionContratosASIC = pd.DataFrame(columns=columnasAsignacionContratosSIC

)

sumAsignacionTotal = 0

sumaproductoVenta = 0

precioPonderadoVenta = 0

sumAsignacionVentaBloque = {}

sumAsignacionCompraBloque = {}

sumAsignacionCompra = {}

sumAsignacionVenta = {}

sumAsignacionCompraBloqueT = {}

sumAsignacionVentaBloqueT = {}

porcentajeAsignacionBloque = {}

reAsignacionCompra = {}

prorataContratos = {}

MAXCOMPRA_C = {}

MAXCOMPRA_T = 0

sumaProductoPrecioPonderado = {}

precioPonderadoCompra = {}

PRECIOPROMEDIOVENTA = {}

reAsignacionCompraT = {}


for v in ofertasVentaOrder.index:

sumAsignacionVentaBloque[v[0]] = 0


sumAsignacionVentaBloqueT[b] = 0


sumaProductoPrecioPonderado[c] = 0

precioPonderadoCompra[c] = 0

reAsignacionCompraT[c] = 0


sumAsignacionCompraBloque[c,b] = 0

sumAsignacionCompra[c] = 0

reAsignacionCompra[c,b] = 0

sumAsignacionCompraBloqueT[b] = 0



prorataContratos[c,v] = 0

fila = 0


if clpe.asignacionV[v[0]].value >= 0.000001:

fila += 1

asignacionVenta = []

asignacionVenta.append(ID_G[v[0]])

asignacionVenta.append(v[0])

asignacionVenta.append(v[1])

asignacionVenta.append(ofertasVentaOrder.numPaquetesMax[v]*paqueteKWH*DUR

ACION[v[1]])

asignacionVenta.append(ofertasVentaOrder.numPaquetesMin[v]*paqueteKWH*DUR

ACION[v[1]])

asignacionVenta.append(PRECIOVENTA[v[0]])

asignacionVenta.append(PRECIOVENTA_DESEMPATADO[v[0]])

asignacionVenta.append(ofertasVentaOrder.simultanea[v])

asignacionVenta.append(ofertasVentaOrder.excluyente[v])

asignacionVenta.append(ofertasVentaOrder.dependiente[v])

asignacionVenta.append(clpe.asignacionV[v[0]].value)

asignacionVenta.append(round((clpe.asignacionV[v[0]].value/(ofertasVentaO

rder.numPaquetesMax[v]*paqueteKWH*DURACION[v[1]]))*100))

out_asignacionVenta.loc[fila] = asignacionVenta

insertar='exec [dbo].[GrabarOfertasVentasPython] ' + "'"+ID_G[v[0]]+"'" +

","+"'"+v[0] + "',"+ "'"+ v[1] + "',"+ str(ofertasVentaOrder.numPaquetesMax[v]*paqueteKWH*DU

RACION[v[1]]) + "," + str(ofertasVentaOrder.numPaquetesMin[v]*paqueteKWH*DURACION[v[1]])


insertar=insertar + ","+str(ofertasVentaOrder.precio_COP_kWh[v]) + "," +

str(PRECIOVENTA_DESEMPATADO[v[0]]) + ",'"+ str(ofertasVentaOrder.simultanea[v]) + "',"

insertar=insertar + "'"+ str(ofertasVentaOrder.excluyente[v]) + "','"+ st

r(ofertasVentaOrder.dependiente[v]) + "'," + str(clpe.asignacionV[v[0]].value) + ","

insertar=insertar + str(round((clpe.asignacionV[v[0]].value/(ofertasVenta

Order.numPaquetesMax[v]*paqueteKWH*DURACION[v[1]]))*100)) + ",'" + procesobd + "'"

cursor.execute(insertar)

conn.commit()


if clpe.asignacionV[v[0]].value >= 0.000001:

BINARIAS_VENTA[v[0]] = clpe.binaria[v[0]].value

ASIGNACION_VENTA[v[0]] = clpe.asignacionV[v[0]].value


if clpe.asignacionC[c].value >= 0.000001:

ASIGNACION_COMPRA[ofertasCompra.nombre[c]] = ASIGNACION_COMPRA[ofertasCom

pra.nombre[c]] + clpe.asignacionC[c].value

fila = 0



fila += 1

asignacionCompra = []

asignacionCompra.append(ID_C[c])

asignacionCompra.append(c)

asignacionCompra.append(PRECIOCOMPRA[c])

asignacionCompra.append(PRECIOCOMPRA_DESEMPATADO[c])


asignacionCompra.append(ofertasCompraOrder.energiaMax_MWh_d[c]*1000)

else:

asignacionCompra.append(MAXCOMPRA[c])

asignacionCompra.append(clpe.asignacionC[c].value)

if ofertasCompraOrder.energiaMax_MWh_d[c] == 0:

asignacionCompra.append(round((clpe.asignacionC[c].value/(DEMANDA_MIN

IMA[ofertasCompraOrder.nombre[c]]))*100))

else:

asignacionCompra.append(round((clpe.asignacionC[c].value/(ofertasComp

raOrder.energiaMax_MWh_d[c]*1000))*100))

out_asignacionCompra.loc[fila] = asignacionCompra

OfertasComprasql=str(asignacionCompra)

OfertasComprasql=OfertasComprasql.replace("[","")

OfertasComprasql=OfertasComprasql.replace("]","")

insertar='exec [dbo].[GrabarOfertasPython] ' + OfertasComprasql + ",'" +

procesobd + "'"



conn.commit()



if v[1] == b:

sumAsignacionVentaBloqueT[v[1]] += clpe.asignacionV[v[0]].value


sumAsignacionTotal += sumAsignacionVentaBloqueT[b]


if sumAsignacionTotal < 0.0000001:

porcentajeAsignacionBloque[b] = 0

else:

porcentajeAsignacionBloque[b] = sumAsignacionVentaBloqueT[b]/sumAsignacio

nTotal

f = 3


f += 1

Concepto=str(b)

InstruccionInsert='exec [dbo].[GrabarresumenResultadosPython] ' + Concepto +

",'" + str(sumAsignacionVentaBloqueT[b]) + " " + str(porcentajeA

signacionBloque[b]) + "','" + procesobd + "'"


Concepto="'TOTAL ASIGNADO kWh-d'"


+ str(sumAsignacionTotal) + "','" + procesobd + "'"


Concepto="'DEMANDA OBJETIVO kWh-d'"


+ str(DEMANDAOBJETIVO*1000) + "','" + procesobd + "'"


Concepto="'DEMANDA SIN ATENDER kWh-d'"


+ str(max(0,DEMANDAOBJETIVO*1000 - sumAsignacionTotal)) + "','" + procesobd + "'"



sumaproductoVenta += PRECIOVENTA[v[0]]*clpe.asignacionV[v[0]].value

if sumAsignacionTotal < 0.0000001:


precioPonderadoVenta = 0

else:

precioPonderadoVenta = sumaproductoVenta/sumAsignacionTotal

Concepto="'PRECIO PONDERADO DE VENTA $/kWh'"


+ str(precioPonderadoVenta) + "','" + procesobd + "'"


Concepto="'PRECIO TOPE PROMEDIO $/kWh'"


+ str(PRECIOTOPE) + "','" + procesobd + "'"


Concepto="'PRECIO TOPE INDIVIDUAL $/kWh'"


+ str(PRECIOMAXIMO) + "','" + procesobd + "'"


fila = 0

if sumAsignacionTotal > 0:


if not clpe.asignacionV[v[0]] == 0:

fila += 1

asignacionContratos = []

asignacionContratos.append(ID_G[v[0]])

asignacionContratos.append(v[0])




prorataContratos[c,v] = clpe.asignacionC[c].value/sumAsignaci

onTotal * clpe.asignacionV[v[0]].value

insertar='exec [dbo].[GrabarOfertasVentasComprasPython] ' + "

'"+v[0] + "','" + c + "','" + v[1] + "'," + str(prorataContratos[c,v])

insertar=insertar + ",'" + procesobd + "'"


conn.commit()

else:

if sumMAXCOMPRA < DEMANDAOBJETIVO*1000:

prorataContratos[c,v] = (MAXCOMPRA[c]/(DEMANDAOBJETIVO*10

00)) * clpe.asignacionV[v[0]].value

insertar='exec [dbo].[GrabarOfertasVentasComprasPython] '

+ "'"+v[0] + "','" + c + "','" + v[1] + "'," + str(prorataContratos[c,v])




conn.commit()

else:

prorataContratos[c,v] = MAXCOMPRA[c]/sumMAXCOMPRA * clpe.

asignacionV[v[0]].value

insertar='exec [dbo].[GrabarOfertasVentasComprasPython] '

+ "'"+v[0] + "','" + c + "','" + v[1] + "'," + str(prorataContratos[c,v])



conn.commit()

asignacionContratos.append(prorataContratos[c,v])

out_asignacionContratos.loc[fila] = asignacionContratos


fila = 0



if not prorataContratos[c,v] == 0:

fila += 1


asignacionContratos.append(c)


asignacionContratos.append("CANTIDAD")


if v[1] == b:

for p in range(Bloques.pi[b],Bloques.pf[b]+1):

asignacionContratos.append(truncate(prorataContratos[c,v]

/DURACION[b],2))

else:


asignacionContratos.append(0)

out_asignacionContratosASIC.loc[fila] = asignacionContratos

ContratosASIC=str(asignacionContratos)

ContratosASIC=ContratosASIC.replace("[","")

ContratosASIC=ContratosASIC.replace("]","")

insertar='exec [dbo].[GrabarContratosASICPython] '+ str(fila) + ","+

ContratosASIC + ",'" + procesobd + "'"


conn.commit()

fila = 0



if not prorataContratos[c,v] == 0:

fila += 1



asignacionContratos.append(c)


asignacionContratos.append("PRECIO")


if v[1] == b:


asignacionContratos.append(PRECIOVENTA[v[0]])

else:


asignacionContratos.append(0)

out_asignacionContratosASIC.loc[fila] = asignacionContratos

ContratosASIC1=str(asignacionContratos)

ContratosASIC1=ContratosASIC1.replace("[","")

ContratosASIC1=ContratosASIC1.replace("]","")

insertar='exec [dbo].[GrabarContratosASICPython] '+ str(fila) + "," +

ContratosASIC1 + ",'" + procesobd + "'"


conn.commit()

energia = 0



insertar='exec [dbo].[GrabarAsignacionesGraficoPython] '+ "'"+c+"','" + I

D_C[c] + "','Compra'," + str(PRECIOCOMPRA[c]) + "," + str(energia) + ",'" + procesobd + "'"


energia = energia + clpe.asignacionC[c].value

insertar='exec [dbo].[GrabarAsignacionesGraficoPython] '+ "'"+c+"','" + I

D_C[c] + "','Compra'," + str(PRECIOCOMPRA[c]) + "," + str(energia) + ",'" + procesobd + "'"


conn.commit()

energia = 0

if sumAsignacionTotal > 0:


if not clpe.asignacionV[v[0]] == 0:

insertar='exec [dbo].[GrabarAsignacionesGraficoPython] '+ "'" + v[0]

+"','" + ID_G[v[0]] + "','Venta'," + str(PRECIOVENTA[v[0]]) + "," + str(energia) + ",'" + pro

cesobd + "'"


insertar='[dbo].[GrabarAsignacionesGraficoPython] ' + "'" + v[0] +"',

'" + ID_G[v[0]] + "','PrecioTopeP'," + str(PRECIOTOPE) + "," + str(energia) + ",'" + procesob

d + "'"



insertar='[dbo].[GrabarAsignacionesGraficoPython] ' + "'" + v[0] +"',

'" + ID_G[v[0]] + "','PrecioTopeI'," + str(PRECIOMAXIMO) + "," + str(energia) + ",'" + proces

obd + "'"


energia = energia + clpe.asignacionV[v[0]].value

insertar='exec [dbo].[GrabarAsignacionesGraficoPython] ' + "'" + v[0]

+"','" + ID_G[v[0]] + "','Venta'," + str(PRECIOVENTA[v[0]]) + "," + str(energia) + ",'" + pr

ocesobd + "'"



+"','" + ID_G[v[0]] + "','PrecioTopeP'," + str(PRECIOTOPE) + "," + str(energia) + ",'" + pro

cesobd + "'"



+"','" + ID_G[v[0]] + "','PrecioTopeI'," + str(PRECIOMAXIMO) + "," + str(energia) + ",'" + p

rocesobd + "'"


conn.commit()

insertar='exec [dbo].[GrabarAsignacionesGraficoPython] ' + "'" + v[0] +"','" + ID

_G[v[0]] + "','DemandaObjetivo'," + str(0) + "," + str(DEMANDAOBJETIVO*1000) + ",'" + proceso

bd + "'"


insertar='exec [dbo].[GrabarAsignacionesGraficoPython] ' + "'" + v[0] +"','" + ID

_G[v[0]] + "','DemandaObjetivo'," + str(PRECIOMAXIMO) + "," + str(DEMANDAOBJETIVO*1000+1) + "

,'" + procesobd + "'"


conn.commit()


print()

print()

break

if sumAsignacionTotal < DEMANDAOBJETIVO*1000:



print()

print("TERMINo EJECUCIoN DE SUBASTA EN FORMA EXITOSA")

print()

print("LA ASIGNACIoN ES MENOR A LA DEMANDA OBJETIVO DEFINIDA POR MINENERGIA")

print()

DEMANDAOBJETIVO = DEMANDAOBJETIVO - sumAsignacionTotal/1000



else:

print("TERMINo CON ASIGNACIoN MAYOR O IGUAL A LA DEMANDA OBJETIVO DEFNIDA POR

MINENERGIA ... STOP ....")


elif (results.solver.termination_condition == TerminationCondition.infeasible):

print("EL PROBLEMA ES INFACTIBLE 2")

print()

print("TERMINo EJECUCIoN CON ERRORES")


elif(results.solver.termination_condition == TerminationCondition.unbounded):

print("EL PROBLEMA ES INFACTIBLE 2")


elif(results.solver.termination_condition == TerminationCondition.maxTimeLimit):

print()

print("TERMINo POR TIEMPO LiMITE")

print()


else:

print ("Solver Status: ", results.solver.status)

print("La solucion del problema es: ",results.solver.termination_condition)

print()



except:

PrintException()

print()


print()


entrega de cÓdigo fuente del algoritmo usado para la ... · medellín, 28 de noviembre de 2019...

Documents