def read(self, cm_xml_path, cdis_xml_path): xmlTree = et.parse(cm_xml_path) xmlRoot = xmlTree.getroot() ceList = [] for ceElement in xmlRoot.findall('ceList'): ceClientList = [] for ceClientElement in ceElement.findall('CEClientList'): id = ceClientElement.find('id').text latitude = float(ceClientElement.find('latitude').text) longitude = float(ceClientElement.find('longitude').text) signal = int(ceClientElement.find('nivelSinal').text) interference = float(ceClientElement.find('interferenciaCocanal').text) ceClient = DataStructures.CEClient(id, DataStructures.GeoPoint(latitude, longitude), signal, interference) ceClientList.append(ceClient) id = ceElement.find('id').text antenna = int(ceElement.find('antena').text) channel = int(ceElement.find('device').find('canal').text) latitude = float(ceElement.find('latitude').text) longitude = float(ceElement.find('longitude').text) potency = int(ceElement.find('potencia').text) maxPotency = int(ceElement.find('potenciaMax').text) ce = DataStructures.CE(id, antenna, channel, DataStructures.GeoPoint(latitude, longitude), potency, maxPotency, ceClientList) ceList.append(ce) id = xmlRoot.find('id').text self.cm = DataStructures.CM(id, ceList) channelList = [] for channelElement in xmlRoot.findall('channels'): name = channelElement.find('nome').text number = int(channelElement.find('numCanal').text) frequency = float(channelElement.find('frequencia').text) state = DataStructures.ChannelState[channelElement.find('estado').text] channel = DataStructures.Channel(name, number, frequency, state) channelList.append(channel) self.channels = channelList xmlTree = et.parse(cdis_xml_path) xmlRoot = xmlTree.getroot() cdisList = [] for cdisElement in xmlRoot.findall('cdis'): cdisChannelList = [] for channelElement in cdisElement.findall('canaisTvdb'): name = channelElement.find('nome').text number = int(channelElement.find('numCanal').text) frequency = float(channelElement.find('frequencia').text) state = DataStructures.ChannelState[channelElement.find('estado').text] channel = DataStructures.Channel(name, number, frequency, state) cdisChannelList.append(channel) cdis = DataStructures.CDIS(cdisChannelList) cdisList.append(cdis) self.cdisList = cdisList
def main(cm_file, cdis_file, output_dir): #------------------------------ BEGIN LOADING ------------------------------# print(">>>: Carregando cenário") scenario = Scenario.Scenario() scenario.read(cm_file, cdis_file) scenario_name = os.path.splitext(os.path.basename(cm_file))[0] cdis_info_name = os.path.splitext(os.path.basename(cdis_file))[0] scenario_path = os.path.join(output_dir, scenario_name + cdis_info_name) result_log_path = os.path.join(scenario_path, "result_log.csv") result_fig_path = os.path.join(scenario_path, "figures") result_res_path = os.path.join(scenario_path, "results") if not os.path.exists(output_dir): os.makedirs(output_dir) if not os.path.exists(scenario_path): os.makedirs(scenario_path) else: shutil.rmtree(scenario_path) os.makedirs(scenario_path) if not os.path.exists(result_fig_path): os.makedirs(result_fig_path) if not os.path.exists(result_res_path): os.makedirs(result_res_path) Visualization.visualize(scenario, scenario.cm.ceList, result_fig_path, "00") #------------------------------ END LOADING ------------------------------# with open(result_log_path, "w+") as resultLogFile: resultLogFile.write( "Data_e_Hora;Nome_do_cenário;Caminho_do_arquivo_do_cenário;Nome_das_informações_do_CDIS;Caminho_do_arquivo_das_informações_do_cdis;Tempo_de_execução\n" ) resultLogFile.write(datetime.now().strftime("%d/%m/%Y %H:%M:%S") + ";" + scenario_name + ";" + cm_file + ";" + cdis_info_name + ";" + cdis_file) startTime = time.time() totalIteration = len(scenario.cdisList) for iteration in range(0, totalIteration): print("\n>>>: Resolvendo cenário com informações do CDIS=" + str(iteration) + "/" + str(totalIteration)) scenario.updateChannels(scenario.cdisList[iteration].channelList) #------------------------------ BEGIN PREPROCESSING ------------------------------# print(">>>: Pré-processando entrada") (allCEVarList, ceVarList, ceByChannelVarList, interferenceList) = PreProcessing.process(scenario) #------------------------------ END PREPROCESSING ------------------------------# #------------------------------ BEGIN SOLVER ------------------------------# print(">>>: Criando modelo") model = gb.Model('cognitive-networks') print(">>>: Adicionando variáveis ao modelo") allCEModelVarList = [] for ceVar in allCEVarList: allCEModelVarList.append( model.addVar(name=ceVar.name, vtype=gb.GRB.BINARY)) ceByChannelModelVarList = [] for ceByChannelVar in ceByChannelVarList: ceByChannelModelVarList.append( model.addVar(name=ceByChannelVar.name)) model.update() ceModelVarList = [] for ceVars in ceVarList: modelVarList = [] for ceVar in ceVars: modelVarList.append(model.getVarByName(ceVar.name)) ceModelVarList.append(modelVarList) print(">>>: Adicionando restrições ao modelo") ceId = 0 for ceModelVars in ceModelVarList: model.addConstr(gb.quicksum(ceModelVars), gb.GRB.EQUAL, 1, "Única_configuração_para_CE_" + str(ceId)) ceId += 1 interferenceModelVarList = [] for interference in interferenceList: ceVar = interference[0] ceTotalInterference = interference[1] ceInterferenceList = interference[2] if (ceTotalInterference > 0): interferenceModelVar = model.addVar( name="Interferência-devido-" + ceVar.name) interferenceModelVarList.append(interferenceModelVar) model.update() ceInterferenceModelVarList = [] for ceInterference in ceInterferenceList: ceInterferenceModelVarList.append( ceInterference * model.getVarByName(ceVar.name)) model.addConstr( gb.quicksum(ceInterferenceModelVarList), gb.GRB.EQUAL, interferenceModelVar, "Interferência_provocada_por_" + ceVar.name) model.addConstr( interferenceModelVar, gb.GRB.LESS_EQUAL, args.max_interference, "Máximo_de_interferência_tolerada_de_" + ceVar.name) for ceByChannelModelVar in ceByChannelModelVarList: ceByChannelVarNameSplit = ceByChannelModelVar.varName.split( '_') channel = int(ceByChannelVarNameSplit[3]) filtredCEModelVarList = PreProcessing.filterCEByChannelModelVar( allCEModelVarList, channel) model.addConstr(gb.quicksum(filtredCEModelVarList), gb.GRB.EQUAL, ceByChannelModelVar, "Qtd_de_CE_no_canal_" + str(channel)) model.addConstr( ceByChannelModelVar, gb.GRB.LESS_EQUAL, min(len(scenario.cm.ceList), ((len(scenario.cm.ceList) / PreProcessing.countAvailableChannels(scenario)) + 1)), "Máximo_de_CEs_no_canal_" + str(channel)) ceId = 0 for ceModelVars in ceModelVarList: potencyList = [] for ceModelVar in ceModelVars: ceModelVarNameSplit = ceModelVar.varName.split("_") cePotency = int(ceModelVarNameSplit[3]) potencyList.append(cePotency * ceModelVar) model.addConstr( gb.quicksum(potencyList), gb.GRB.GREATER_EQUAL, args.min_potency, "Mínimo_de_potência_para_máxima_cobertura_do_CE_" + str(ceId)) ceId += 1 print(">>>: Definindo a função objetivo") model.setObjective(gb.quicksum(interferenceModelVarList), gb.GRB.MINIMIZE) model.write( os.path.join(result_res_path, "model_it_" + str(iteration) + ".lp")) print(">>>: Modelo salvo") print(">>>: Otimizando modelo") model.optimize() resultCEVarList = [] with open( os.path.join(result_res_path, "it_" + str(iteration) + ".txt"), "w") as resultFile: if (model.status == gb.GRB.Status.OPTIMAL): resultFile.write(">>>: Resultado ótimo:\n") print(">>>: Resultado ótimo:") for ceModelVar in allCEModelVarList: if (ceModelVar.x == 1.0): resultCEVarList.append(ceModelVar.varName) resultFile.write("%s\n" % ceModelVar.varName) print("%s" % ceModelVar.varName) for interferenceModelVar in interferenceModelVarList: ceModelVar = model.getVarByName( interferenceModelVar.varName.split("-")[2]) if ((ceModelVar.x == 1.0) and (interferenceModelVar.x > 0.0)): resultFile.write("%s %s\n" % (interferenceModelVar.varName, interferenceModelVar.x)) print("%s %s" % (interferenceModelVar.varName, interferenceModelVar.x)) for ceByChannelModelVar in ceByChannelModelVarList: resultFile.write("%s %s\n" % (ceByChannelModelVar.varName, ceByChannelModelVar.x)) print("%s %s" % (ceByChannelModelVar.varName, ceByChannelModelVar.x)) elif (model.status == gb.GRB.Status.INFEASIBLE): resultFile.write(">>>: O modelo é inviável!\n") print(">>>: O modelo é inviável!") print(">>>: Computando IIS") model.computeIIS() resultFile.write( "\n>>>: As restrições a seguir não foram satisfeitas:\n" ) print(">>>: As restrições a seguir não foram satisfeitas:") for c in model.getConstrs(): if c.IISConstr: resultFile.write("%s\n" % c.constrName) print("%s" % c.constrName) print(">>>: Otimizando modelo relaxado") model.feasRelaxS(0, False, False, True) model.optimize() if (model.status == gb.GRB.Status.OPTIMAL): resultFile.write( "\n>>>: Resultado ótimo do modelo relaxado:\n") print(">>>: Resultado ótimo do modelo relaxado:") for ceModelVar in allCEModelVarList: if (ceModelVar.x == 1.0): resultCEVarList.append(ceModelVar.varName) resultFile.write("%s\n" % ceModelVar.varName) print("%s" % ceModelVar.varName) for interferenceModelVar in interferenceModelVarList: ceModelVar = model.getVarByName( interferenceModelVar.varName.split("-")[2]) if ((ceModelVar.x == 1.0) and (interferenceModelVar.x > 0.0)): resultFile.write("%s %s\n" % (interferenceModelVar.varName, interferenceModelVar.x)) print("%s %s" % (interferenceModelVar.varName, interferenceModelVar.x)) for ceByChannelModelVar in ceByChannelModelVarList: resultFile.write("%s %s\n" % (ceByChannelModelVar.varName, ceByChannelModelVar.x)) print("%s %s" % (ceByChannelModelVar.varName, ceByChannelModelVar.x)) elif (model.status in (gb.GRB.Status.INF_OR_UNBD, gb.GRB.Status.UNBOUNDED, gb.GRB.Status.INFEASIBLE)): print( ">>>: O modelo relaxado não pode ser resolvido porque é ilimitado ou inviável" ) else: resultFile.write( ">>>: A otimização parou com status: %d\n" % model.status) print(">>>: A otimização parou com status: %d" % model.status) elif (model.status == gb.GRB.Status.UNBOUNDED): resultFile.write( ">>>: O modelo não pode ser resolvido porque é ilimitado\n" ) print( ">>>: O modelo não pode ser resolvido porque é ilimitado" ) else: resultFile.write( ">>>: A otimização parou com status: %d\n" % model.status) print(">>>: A otimização parou com status: %d" % model.status) resultCEList = [] for resultCEVar in resultCEVarList: ceVarNameSplit = resultCEVar.split('_') ceId = int(ceVarNameSplit[1]) resultCEChannelNumber = int(ceVarNameSplit[2]) resultCEPotency = int(ceVarNameSplit[3]) ce = scenario.cm.ceList[ceId] resultCEList.append( DataStructures.CE(ceId, ce.antenna, resultCEChannelNumber, ce.geoPoint, resultCEPotency, ce.maxPotency, ce.clientList)) #------------------------------ END SOLVER ------------------------------# #------------------------------ BEGIN VISUALIZATION ------------------------------# if (len(resultCEVarList) > 0): Visualization.visualize(scenario, resultCEList, result_fig_path, str(iteration)) #------------------------------ END VISUALIZATION ------------------------------# resultLogFile.write(";" + str((time.time() - startTime)))