from typing import IO, List, Type
from idecomp._utils.utils import formata_numero
from idecomp._utils.registros import RegistroAn, RegistroFn, RegistroIn
from idecomp._utils.registrodecomp import RegistroDecomp
from idecomp._utils.registrodecomp import TipoRegistroAC
from idecomp._utils.leituraregistros import LeituraRegistros
[documentos]class TE(RegistroDecomp):
"""
Registro que contém o nome do estudo do DECOMP.
"""
mnemonico = "TE"
def __init__(self):
super().__init__(TE.mnemonico, True)
self._dados: str = ""
def le(self):
reg_linha = RegistroAn(75)
self._dados = reg_linha.le_registro(self._linha, 4)
def escreve(self, arq: IO):
linha = f"{TE.mnemonico}".ljust(4) + self.dados + "\n"
arq.write(linha)
@property
def titulo(self) -> str:
"""
O único conteúdo do registro (título do estudo).
:return: Uma `str` com o título do estudo
"""
return self._dados
@titulo.setter
def titulo(self, t: str):
self._dados = t
[documentos]class SB(RegistroDecomp):
"""
Registro que contém o cadastro dos subsistemas.
"""
mnemonico = "SB"
def __init__(self):
super().__init__(SB.mnemonico, True)
self._dados = [0, ""]
def le(self):
reg_indice = RegistroIn(2)
reg_mnemonico = RegistroAn(2)
self._dados[0] = reg_indice.le_registro(self._linha, 4)
self._dados[1] = reg_mnemonico.le_registro(self._linha, 9)
def escreve(self, arq: IO):
linha = (f"{SB.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(2) + " " +
f"{self._dados[1]}".ljust(2) + "\n")
arq.write(linha)
@property
def codigo(self) -> int:
"""
O código de cadastro do subsistema.
:return: O código como `int`.
"""
return self._dados[0]
@codigo.setter
def codigo(self, cod: int):
self._dados[0] = cod
@property
def nome(self) -> str:
"""
O nome de cadastro do subsistema.
:return: O nome como `str`.
"""
return self._dados[1]
@nome.setter
def nome(self, n: str):
self._dados[1] = n
[documentos]class UH(RegistroDecomp):
"""
Registro que contém o cadastro das UHEs, com os seus volumes
iniciais no estudo.
"""
mnemonico = "UH"
def __init__(self):
super().__init__(UH.mnemonico, True)
self._dados = [0, 0, 0.0, True, -1.0]
def le(self):
reg_indice = RegistroIn(3)
reg_ree = RegistroIn(2)
reg_vini = RegistroFn(6)
reg_evap = RegistroIn(1)
reg_vert = RegistroFn(10)
self._dados[0] = reg_indice.le_registro(self._linha, 4)
self._dados[1] = reg_ree.le_registro(self._linha, 9)
self._dados[2] = reg_vini.le_registro(self._linha, 18)
if len(self._linha[39:40].strip()) > 0:
self._dados[3] = bool(reg_evap.le_registro(self._linha, 39))
if len(self._linha[59:69].strip()) > 0:
self._dados[4] = reg_vert.le_registro(self._linha, 59)
def escreve(self, arq: IO):
linha = (f"{UH.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{round(self._dados[2], 2)}".rjust(6) + " " +
f"{int(self._dados[3])}")
if self._dados[4] != -1.0:
linha += " "
linha += f"{round(self._dados[4], 2)}".rjust(10)
linha += "\n"
arq.write(linha)
@property
def codigo(self) -> int:
"""
O código de cadastro da UHE.
:return: O código como um `int`.
"""
return self._dados[0]
@property
def ree(self) -> int:
"""
O REE de cadastro da UHE.
:return: O REE como um `int`.
"""
return self._dados[1]
@ree.setter
def ree(self, r: int):
self._dados[1] = r
@property
def volume_inicial(self) -> float:
"""
O volume inicial da UHE para o estudo.
:return: O volume como um `float`.
"""
return self._dados[2]
@volume_inicial.setter
def volume_inicial(self, v: float):
self._dados[2] = v
@property
def evaporacao(self) -> bool:
"""
A consideração ou não de evaporação para a UHE.
:return: A consideração como um `bool`.
"""
return self._dados[3]
@evaporacao.setter
def evaporacao(self, e: bool):
self._dados[3] = e
[documentos]class CT(RegistroDecomp):
"""
Registro que contém o cadastro das usinas termelétricas com
os seus custos e capacidades.
"""
mnemonico = "CT"
def __init__(self):
super().__init__(CT.mnemonico, True)
self._dados = [0, 0, "", 0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0]
def le(self):
reg_codigo = RegistroIn(3)
reg_subsis = RegistroIn(2)
reg_nome = RegistroAn(10)
reg_estagio = RegistroIn(2)
reg_inflex = RegistroFn(5)
reg_disp = RegistroFn(5)
reg_cvu = RegistroFn(10)
self._dados[0] = reg_codigo.le_registro(self._linha, 4)
self._dados[1] = reg_subsis.le_registro(self._linha, 9)
self._dados[2] = reg_nome.le_registro(self._linha, 14)
self._dados[3] = reg_estagio.le_registro(self._linha, 24)
self._dados[4] = reg_inflex.le_registro(self._linha, 29)
self._dados[5] = reg_disp.le_registro(self._linha, 34)
self._dados[6] = reg_cvu.le_registro(self._linha, 39)
self._dados[7] = reg_inflex.le_registro(self._linha, 49)
self._dados[8] = reg_disp.le_registro(self._linha, 54)
self._dados[9] = reg_cvu.le_registro(self._linha, 59)
self._dados[10] = reg_inflex.le_registro(self._linha, 69)
self._dados[11] = reg_disp.le_registro(self._linha, 74)
self._dados[12] = reg_cvu.le_registro(self._linha, 79)
def escreve(self, arq: IO):
linha = (f"{CT.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".ljust(10) +
f"{self._dados[3]}".rjust(2) + " " +
formata_numero(self._dados[4], 2, 5) +
formata_numero(self._dados[5], 2, 5) +
f"{self._dados[6]:10.2f}" +
formata_numero(self._dados[7], 2, 5) +
formata_numero(self._dados[8], 2, 5) +
f"{self._dados[9]:10.2f}" +
formata_numero(self._dados[10], 2, 5) +
formata_numero(self._dados[11], 2, 5) +
f"{self._dados[12]:10.2f}" + "\n")
arq.write(linha)
@property
def codigo(self) -> int:
"""
O código de cadastro da UTE.
:return: O código como um `int`.
"""
return self._dados[0]
@property
def subsistema(self) -> int:
"""
O subsistema de cadastro da UTE.
:return: O subsistema como um `int`.
"""
return self._dados[1]
@property
def nome(self) -> str:
"""
O nome de cadastro da UTE.
:return: O nome como uma `str`.
"""
return self._dados[2]
@nome.setter
def nome(self, nome: str):
self._dados[2] = nome
@property
def estagio(self) -> str:
"""
O estágio associado às propriedades cadastradas.
:return: O estágio como um `int`.
"""
return self._dados[3]
@property
def inflexibilidades(self) -> List[float]:
"""
As inflexibilidades da UTE por patamar.
:return: As inflexibilidades como `list[float]`.
"""
return self._dados[4::3]
@inflexibilidades.setter
def inflexibilidades(self, inflex: List[float]):
novas = len(inflex)
atuais = len(self.inflexibilidades)
if novas != atuais:
raise ValueError("Número de inflexibilidades incompatível. De" +
f"vem ser fornecidas {atuais}, mas foram {novas}")
self._dados[4::3] = inflex
@property
def disponibilidades(self) -> List[float]:
"""
As disponibilidades da UTE por patamar.
:return: As disponibilidades como `list[float]`.
"""
return self._dados[5::3]
@disponibilidades.setter
def disponibilidades(self, disp: List[float]):
novas = len(disp)
atuais = len(self.disponibilidades)
if novas != atuais:
raise ValueError("Número de disponibilidades incompatível. De" +
f"vem ser fornecidas {atuais}, mas foram {novas}")
self._dados[5::3] = disp
@property
def cvus(self) -> List[float]:
"""
Os CVUs da UTE por patamar.
:return: Os CVUs como `list[float]`.
"""
return self._dados[6::3]
@cvus.setter
def cvus(self, cvu: List[float]):
novas = len(cvu)
atuais = len(self.cvus)
if novas != atuais:
raise ValueError("Número de CVUs incompatível. De" +
f"vem ser fornecidas {atuais}, mas foram {novas}")
self._dados[6::3] = cvu
[documentos]class UE(RegistroDecomp):
"""
Registro que contém o cadastro das estações de bombeamento
(usinas elevatórias).
"""
mnemonico = "UE"
def __init__(self):
super().__init__(UE.mnemonico, True)
self._dados = [0, 0, "", 0, 0, 0.0, 0.0, 0.0]
def le(self):
reg_codigo = RegistroIn(3)
reg_subsis = RegistroIn(2)
reg_nome = RegistroAn(12)
reg_montante = RegistroIn(3)
reg_jusante = RegistroIn(3)
reg_bomb = RegistroFn(10)
self._dados[0] = reg_codigo.le_registro(self._linha, 4)
self._dados[1] = reg_subsis.le_registro(self._linha, 9)
self._dados[2] = reg_nome.le_registro(self._linha, 14)
self._dados[3] = reg_montante.le_registro(self._linha, 29)
self._dados[4] = reg_jusante.le_registro(self._linha, 34)
self._dados[5] = reg_bomb.le_registro(self._linha, 39)
self._dados[6] = reg_bomb.le_registro(self._linha, 49)
self._dados[7] = reg_bomb.le_registro(self._linha, 59)
def escreve(self, arq: IO):
linha = (f"{UE.mnemonico}".ljust(4) +
f"{self._dados[0]}".zfill(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".ljust(12) + " " +
f"{self._dados[3]}".rjust(3) + " " +
f"{self._dados[4]}".rjust(3) + " " +
f"{self._dados[5]:10.1f}" +
f"{self._dados[6]:10.1f}" +
f"{self._dados[7]:10.2f}" + "\n")
arq.write(linha)
[documentos]class DP(RegistroDecomp):
"""
Registro que contém o cadastro das durações dos patamares.
"""
mnemonico = "DP"
def __init__(self):
super().__init__(DP.mnemonico, True)
self._dados = [0, 0, 0,
0.0, 0.0,
0.0, 0.0,
0.0, 0.0]
def le(self):
reg_estagio = RegistroIn(2)
reg_subsis = RegistroIn(2)
reg_num = RegistroIn(1)
reg_carga = RegistroFn(10)
reg_duracao = RegistroFn(10)
self._dados[0] = reg_estagio.le_registro(self._linha, 4)
self._dados[1] = reg_subsis.le_registro(self._linha, 9)
self._dados[2] = reg_num.le_registro(self._linha, 14)
if len(self._linha[19:29].strip()) > 0:
self._dados[3] = reg_carga.le_registro(self._linha, 19)
self._dados[4] = reg_duracao.le_registro(self._linha, 29)
if len(self._linha[39:49].strip()) > 0:
self._dados[5] = reg_carga.le_registro(self._linha, 39)
self._dados[6] = reg_duracao.le_registro(self._linha, 49)
if len(self._linha[59:69].strip()) > 0:
self._dados[7] = reg_carga.le_registro(self._linha, 59)
self._dados[8] = reg_duracao.le_registro(self._linha, 69)
def escreve(self, arq: IO):
linha = (f"{DP.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(2) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".rjust(1) + " ")
if self._dados[3] != 0.0:
linha += f"{self._dados[3]:10.1f}"
else:
linha += " "
linha += f"{self._dados[4]:10.1f}"
if self._dados[5] != 0.0:
linha += f"{self._dados[5]:10.1f}"
else:
linha += " "
linha += f"{self._dados[6]:10.1f}"
if self._dados[7] != 0.0:
linha += f"{self._dados[7]:10.1f}"
else:
linha += " "
linha += f"{self._dados[8]:10.1f}"
arq.write(linha + "\n")
@property
def estagio(self) -> int:
"""
O estágio associado às durações especificadas.
:return: O estágio como `int`.
"""
return self._dados[0]
@property
def subsistema(self) -> int:
"""
O subsistema associado às durações especificadas.
:return: O subsistema como `int`.
"""
return self._dados[1]
@subsistema.setter
def subsistema(self, sub: int):
self._dados[1] = sub
@property
def num_patamares(self) -> int:
"""
O número de patamares.
:return: O número como `int`.
"""
return self._dados[2]
@property
def cargas(self) -> List[float]:
"""
As cargas em Mwmed pata cada patamar de carga
:return: As cargas como `list[float]`.
"""
return self._dados[3::2]
@cargas.setter
def cargas(self, c: List[float]):
novas = len(c)
atuais = len(self.cargas)
if novas != atuais:
raise ValueError("Número de cargas incompatível. De" +
f"vem ser fornecidas {atuais}, mas foram {novas}")
self._dados[3::2] = c
@property
def duracoes(self) -> List[float]:
"""
As durações de cada patamar de carga em horas
:return: As durações como `list[float]`.
"""
return self._dados[4::2]
@duracoes.setter
def duracoes(self, d: List[float]):
novas = len(d)
atuais = len(self.duracoes)
if novas != atuais:
raise ValueError("Número de durações incompatível. De" +
f"vem ser fornecidas {atuais}, mas foram {novas}")
self._dados[4::2] = d
[documentos]class CD(RegistroDecomp):
"""
Registro que contém o cadastro dos custos de déficit.
"""
mnemonico = "CD"
def __init__(self):
super().__init__(CD.mnemonico, True)
self._dados = [0, 0, "", 0,
0.0, 0.0,
0.0, 0.0,
0.0, 0.0]
def le(self):
reg_num_curva = RegistroIn(2)
reg_subsis = RegistroIn(2)
reg_nome = RegistroAn(10)
reg_estagio = RegistroIn(2)
reg_limite = RegistroFn(5)
reg_custo = RegistroFn(10)
self._dados[0] = reg_num_curva.le_registro(self._linha, 4)
self._dados[1] = reg_subsis.le_registro(self._linha, 9)
self._dados[2] = reg_nome.le_registro(self._linha, 14)
self._dados[3] = reg_estagio.le_registro(self._linha, 24)
self._dados[4] = reg_limite.le_registro(self._linha, 29)
self._dados[5] = reg_custo.le_registro(self._linha, 34)
self._dados[6] = reg_limite.le_registro(self._linha, 44)
self._dados[7] = reg_custo.le_registro(self._linha, 49)
self._dados[8] = reg_limite.le_registro(self._linha, 59)
self._dados[9] = reg_custo.le_registro(self._linha, 64)
def escreve(self, arq: IO):
linha = (f"{CD.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(2) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".ljust(10) +
f"{self._dados[3]}".rjust(2) + " " +
f"{self._dados[4]:5.0f}" +
f"{self._dados[5]:10.2f}" +
f"{self._dados[6]:5.0f}" +
f"{self._dados[7]:10.2f}" +
f"{self._dados[8]:5.0f}" +
f"{self._dados[9]:10.2f}" + "\n")
arq.write(linha)
@property
def numero_curva(self) -> int:
return self._dados[0]
@numero_curva.setter
def numero_curva(self, n: int):
self._dados[0] = n
@property
def subsistema(self) -> int:
return self._dados[1]
@subsistema.setter
def subsistema(self, s: int):
self._dados[1] = s
@property
def nome_curva(self) -> str:
return self._dados[2]
@nome_curva.setter
def nome_curva(self, n: str):
self._dados[2] = n
@property
def estagio(self) -> int:
return self._dados[3]
@estagio.setter
def estagio(self, e: int):
self._dados[3] = e
@property
def limites_superiores(self) -> List[float]:
return self._dados[4::2]
@limites_superiores.setter
def limites_superiores(self, lim: List[float]):
novos = len(lim)
atuais = len(self.limites_superiores)
if novos != atuais:
raise ValueError("Número de limites incompatível. De" +
f"vem ser fornecidos {atuais}, mas foram {novos}")
self._dados[4::2] = lim
@property
def custos(self) -> List[float]:
return self._dados[5::2]
@custos.setter
def custos(self, cus: List[float]):
novos = len(cus)
atuais = len(self.custos)
if novos != atuais:
raise ValueError("Número de custos incompatível. De" +
f"vem ser fornecidos {atuais}, mas foram {novos}")
self._dados[5::2] = cus
[documentos]class PQ(RegistroDecomp):
"""
Registro que contém as gerações de pequenas usinas, não
incluídas no despacho.
"""
mnemonico = "PQ"
def __init__(self):
super().__init__(PQ.mnemonico, True)
self._dados = ["", 0, 0, 0.0, 0.0, 0.0]
def le(self):
reg_nome = RegistroAn(10)
reg_subsis = RegistroIn(2)
reg_estagio = RegistroIn(2)
reg_custo = RegistroFn(5)
self._dados[0] = reg_nome.le_registro(self._linha, 4)
self._dados[1] = reg_subsis.le_registro(self._linha, 15)
self._dados[2] = reg_estagio.le_registro(self._linha, 19)
self._dados[3] = reg_custo.le_registro(self._linha, 24)
self._dados[4] = reg_custo.le_registro(self._linha, 29)
self._dados[5] = reg_custo.le_registro(self._linha, 34)
def escreve(self, arq: IO):
linha = (f"{PQ.mnemonico}".ljust(4) +
f"{self._dados[0]}".ljust(10) + " " +
f"{self._dados[1]}".rjust(1) + " " +
f"{self._dados[2]}".rjust(2) + " " +
f"{self._dados[3]:5.0f}" +
f"{self._dados[4]:5.0f}" +
f"{self._dados[5]:5.0f}" + "\n")
arq.write(linha)
[documentos]class RI(RegistroDecomp):
"""
Registro que contém as restrições de Itaipu.
"""
mnemonico = "RI"
def __init__(self):
super().__init__(RI.mnemonico, True)
self._dados = [0, 0, 0,
0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0]
def le(self):
reg_uhe = RegistroIn(3)
reg_estagio = RegistroIn(2)
reg_subsis = RegistroIn(3)
reg_minmax = RegistroFn(7)
self._dados[0] = reg_uhe.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
self._dados[2] = reg_subsis.le_registro(self._linha, 13)
tab = reg_minmax.le_linha_tabela(self._linha, 16, 0, 15)
for i, t in enumerate(tab, start=3):
self._dados[i] = t
def escreve(self, arq: IO):
linha = (f"{RI.mnemonico}".ljust(3) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".rjust(2) + " ")
for i in range(3, len(self._dados)):
linha += f"{self._dados[i]:7.0f}"
linha += "\n"
arq.write(linha)
[documentos]class IA(RegistroDecomp):
"""
Registro que contém os limites de intercâmbio entre os subsistemas.
"""
mnemonico = "IA"
def __init__(self):
super().__init__(IA.mnemonico, True)
self._dados = [0, "", "",
0.0, 0.0,
0.0, 0.0,
0.0, 0.0]
def le(self):
reg_estagio = RegistroIn(2)
reg_subsis = RegistroAn(2)
reg_limite = RegistroFn(10)
self._dados[0] = reg_estagio.le_registro(self._linha, 4)
self._dados[1] = reg_subsis.le_registro(self._linha, 9)
self._dados[2] = reg_subsis.le_registro(self._linha, 14)
tab = reg_limite.le_linha_tabela(self._linha, 19, 0, 6)
for i, t in enumerate(tab, start=3):
self._dados[i] = t
def escreve(self, arq: IO):
linha = (f"{IA.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(2) + " " +
f"{self._dados[1]}".ljust(2) + " " +
f"{self._dados[2]}".ljust(2) + " ")
for i in range(3, len(self._dados)):
linha += f"{self._dados[i]:10.0f}"
linha += "\n"
arq.write(linha)
[documentos]class TX(RegistroDecomp):
"""
Registro que contém a taxa de desconto anual do modelo.
"""
mnemonico = "TX"
def __init__(self):
super().__init__(TX.mnemonico, True)
self._dados: float = 0.0
def le(self):
reg_linha = RegistroFn(5)
self._dados = reg_linha.le_registro(self._linha, 4)
def escreve(self, arq: IO):
linha = (f"{TX.mnemonico}".ljust(4) +
f"{round(self.dados, 2)}".rjust(5) +
"\n")
arq.write(linha)
@property
def taxa(self) -> float:
"""
A taxa de desconto em % utilizada no estudo
:return: As taxa como `float`.
"""
return self._dados
@taxa.setter
def taxa(self, t: float):
self._dados = t
[documentos]class GP(RegistroDecomp):
"""
Registro que contém o gap de tolerância para convergência.
"""
mnemonico = "GP"
def __init__(self):
super().__init__(GP.mnemonico, True)
self._dados: float = 0.0
def le(self):
reg_linha = RegistroFn(10)
self._dados = reg_linha.le_registro(self._linha, 4)
def escreve(self, arq: IO):
linha = (f"{GP.mnemonico}".ljust(4) +
f"{round(self.dados, 8)}".rjust(10) +
"\n")
arq.write(linha)
@property
def gap(self) -> float:
"""
O gap considerado para convergência no estudo
:return: O gap como `float`.
"""
return self._dados
@gap.setter
def gap(self, g: float):
self._dados = g
[documentos]class NI(RegistroDecomp):
"""
Registro que contém o número máximo de iterações do modelo.
"""
mnemonico = "NI"
def __init__(self):
super().__init__(NI.mnemonico, True)
self._dados: int = 0
def le(self):
reg_linha = RegistroIn(3)
self._dados = reg_linha.le_registro(self._linha, 4)
def escreve(self, arq: IO):
linha = f"{NI.mnemonico}".ljust(4) + f"{self.dados}".rjust(3) + "\n"
arq.write(linha)
@property
def iteracoes(self) -> int:
"""
O número máximo de iterações do modelo no estudo
:return: O número de iterações como `int`.
"""
return self._dados
@iteracoes.setter
def iteracoes(self, i: int):
self._dados = i
[documentos]class DT(RegistroDecomp):
"""
Registro que contém a data de referência do estudo.
"""
mnemonico = "DT"
def __init__(self):
super().__init__(DT.mnemonico, True)
self._dados = [0, 0, 0]
def le(self):
reg_diames = RegistroIn(2)
reg_ano = RegistroIn(4)
self._dados[0] = reg_diames.le_registro(self._linha, 4)
self._dados[1] = reg_diames.le_registro(self._linha, 9)
self._dados[2] = reg_ano.le_registro(self._linha, 14)
def escreve(self, arq: IO):
linha = (f"{DT.mnemonico}".ljust(4) +
f"{self.dados[0]}".rjust(2) + " " +
f"{self.dados[1]}".zfill(2) + " " +
f"{self.dados[2]}".rjust(4) + "\n")
arq.write(linha)
@property
def dia(self) -> int:
"""
O dia de referência para realização do estudo
:return: O dia como `int`.
"""
return self._dados[0]
@dia.setter
def dia(self, d: int):
self._dados[0] = d
@property
def mes(self) -> int:
"""
O mês de referência para realização do estudo
:return: O mês como `int`.
"""
return self._dados[1]
@mes.setter
def mes(self, m: int):
self._dados[1] = m
@property
def ano(self) -> int:
"""
O ano de referência para realização do estudo
:return: O ano como `int`.
"""
return self._dados[2]
@ano.setter
def ano(self, a: int):
self._dados[2] = a
[documentos]class MP(RegistroDecomp):
"""
Registro que contém as manutenções programadas das UHEs.
"""
mnemonico = "MP"
def __init__(self):
super().__init__(MP.mnemonico, True)
self._dados = [0, 0]
def le(self):
reg_uhe = RegistroIn(3)
reg_frequencia = RegistroIn(2)
reg_manutencao = RegistroFn(5)
self._dados[0] = reg_uhe.le_registro(self._linha, 4)
if self._linha[7:9].strip().isnumeric():
self._dados[1] = reg_frequencia.le_registro(self._linha, 7)
ci = 9
for i in range(2, 26):
cf = ci + 5
if len(self._linha[ci:cf].strip()) == 0:
break
self._dados.append(reg_manutencao.le_registro(self._linha, ci))
ci = cf
def escreve(self, arq: IO):
linha = (f"{MP.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3))
linha += " " if self._dados[1] == 0 else f"{self._dados[1]}"
for i in range(2, len(self._dados)):
linha += f"{self._dados[i]:1.3f}"
linha += "\n"
arq.write(linha)
[documentos]class MT(RegistroDecomp):
"""
Registro que contém as manutenções programadas das UTEs.
"""
mnemonico = "MT"
def __init__(self):
super().__init__(MT.mnemonico, True)
self._dados = [0, 0]
def le(self):
reg_ute = RegistroIn(3)
reg_subsis = RegistroIn(2)
reg_manutencao = RegistroFn(5)
self._dados[0] = reg_ute.le_registro(self._linha, 4)
self._dados[1] = reg_subsis.le_registro(self._linha, 9)
ci = 14
for i in range(2, 26):
cf = ci + 5
if len(self._linha[ci:cf].strip()) == 0:
break
self._dados.append(reg_manutencao.le_registro(self._linha, ci))
ci = cf
def escreve(self, arq: IO):
linha = (f"{MT.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " ")
for i in range(2, len(self._dados)):
linha += f"{self._dados[i]:1.3f}"
linha += "\n"
arq.write(linha)
[documentos]class FD(RegistroDecomp):
"""
Registro que contém os fatores de disponibilidade das UHEs.
"""
mnemonico = "FD"
def __init__(self):
super().__init__(FD.mnemonico, True)
self._dados = [0, 0]
def le(self):
reg_uhe = RegistroIn(3)
reg_manutencao = RegistroFn(5)
reg_frequencia = RegistroIn(2)
self._dados[0] = reg_uhe.le_registro(self._linha, 4)
if self._linha[7:9].strip().isnumeric():
self._dados[1] = reg_frequencia.le_registro(self._linha, 7)
ci = 9
for i in range(2, 25):
cf = ci + 5
if len(self._linha[ci:cf].strip()) == 0:
break
self._dados.append(reg_manutencao.le_registro(self._linha, ci))
ci = cf
def escreve(self, arq: IO):
linha = (f"{FD.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3))
linha += " " if self._dados[1] == 0 else f"{self._dados[1]}"
for i in range(2, len(self._dados)):
linha += f"{self._dados[i]:1.3f}"
linha += "\n"
arq.write(linha)
[documentos]class VE(RegistroDecomp):
"""
Registro que contém os volumes de espera das UHEs.
"""
mnemonico = "VE"
def __init__(self):
super().__init__(VE.mnemonico, True)
self._dados = [0]
def le(self):
reg_uhe = RegistroIn(3)
reg_manutencao = RegistroFn(5)
self._dados[0] = reg_uhe.le_registro(self._linha, 4)
ci = 9
for i in range(1, 25):
cf = ci + 5
if len(self._linha[ci:cf].strip()) == 0:
break
self._dados.append(reg_manutencao.le_registro(self._linha, ci))
ci = cf
def escreve(self, arq: IO):
linha = (f"{VE.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " ")
for i in range(1, len(self._dados)):
a_escrever = f"{round(self._dados[i], 2)}".rjust(5)
if len(a_escrever) > 5:
a_escrever = f"{round(self._dados[i], 1)}".rjust(5)
if len(a_escrever) > 5:
a_escrever = f"{int(self._dados[i])}".rjust(5)
linha += a_escrever
linha += "\n"
arq.write(linha)
@property
def codigo(self) -> int:
"""
O código do posto associado ao volume
:return: O código como `int`.
"""
return self._dados[0]
[documentos]class RE(RegistroDecomp):
"""
Registro que contém os cadastros de restrições elétricas.
"""
mnemonico = "RE"
def __init__(self):
super().__init__(RE.mnemonico, True)
self._dados = [0, 0, 0]
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(2)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
self._dados[2] = reg_estagio.le_registro(self._linha, 14)
def escreve(self, arq: IO):
linha = (f"{RE.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".rjust(2) + "\n")
arq.write(linha)
@property
def codigo(self) -> int:
"""
O código de cadastro para a restrição
:return: O código como `int`.
"""
return self._dados[0]
@property
def estagio_inicial(self) -> int:
"""
O estágio inicial para consideração da restrição
:return: O estágio como `int`.
"""
return self._dados[1]
@property
def estagio_final(self) -> int:
"""
O estágio final para consideração da restrição
:return: O estágio como `int`.
"""
return self._dados[2]
[documentos]class LU(RegistroDecomp):
"""
Registro que contém os cadastros de restrições elétricas.
"""
mnemonico = "LU"
default = 1e21
def __init__(self):
super().__init__(LU.mnemonico, True)
self._dados = [0, 0] + [LU.default] * 6
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(2)
reg_limite = RegistroFn(10)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
ci = 14
for i in range(2, len(self._dados)):
cf = ci + 10
if len(self._linha[ci:cf].strip()) != 0:
self._dados[i] = reg_limite.le_registro(self._linha, ci)
ci = cf
def escreve(self, arq: IO):
linha = (f"{LU.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " ")
for i in range(2, len(self._dados)):
if self._dados[i] != LU.default:
linha += f"{round(self._dados[i], 2)}".rjust(10)
else:
linha += " "
arq.write(linha + "\n")
@property
def codigo(self) -> int:
"""
O código da restrição RE associada aos limites
:return: O código como `int`.
"""
return self._dados[0]
@property
def estagio(self) -> int:
"""
O estágio inicial para consideração dos limites, até
que sejam especificados novos limites.
:return: O estágio como `int`.
"""
return self._dados[1]
@estagio.setter
def estagio(self, e: int):
self._dados[1] = e
@property
def limites_inferiores(self) -> List[float]:
"""
Os limites inferiores por patamar para a restrição elétrica
:return: Os limites como `list[float]`
"""
return self._dados[2::2]
@limites_inferiores.setter
def limites_inferiores(self, lim: List[float]):
novos = len(lim)
atuais = len(self.limites_inferiores)
if novos != atuais:
raise ValueError("Número de limites incompatível. De" +
f"vem ser fornecidos {atuais}, mas foram {novos}")
self._dados[2::2] = lim
@property
def limites_superiores(self) -> List[float]:
"""
Os limites superiores por patamar para a restrição elétrica
:return: Os limites como `list[float]`
"""
return self._dados[3::2]
@limites_superiores.setter
def limites_superiores(self, lim: List[float]):
novos = len(lim)
atuais = len(self.limites_superiores)
if novos != atuais:
raise ValueError("Número de limites incompatível. De" +
f"vem ser fornecidos {atuais}, mas foram {novos}")
self._dados[3::2] = lim
[documentos]class FU(RegistroDecomp):
"""
Registro que contém os coeficientes das usinas hidráulicas
nas restrições elétricas.
"""
mnemonico = "FU"
def __init__(self):
super().__init__(FU.mnemonico, True)
self._dados = [0, 0, 0, 0.0, 0]
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(2)
reg_uhe = RegistroIn(3)
reg_fator = RegistroFn(10)
reg_freq = RegistroIn(2)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
self._dados[2] = reg_uhe.le_registro(self._linha, 14)
self._dados[3] = reg_fator.le_registro(self._linha, 19)
if self._linha[30:32].strip().isnumeric():
self._dados[4] = reg_freq.le_registro(self._linha, 30)
def escreve(self, arq: IO):
linha = (f"{FU.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".rjust(3) + " " +
f"{round(self._dados[3], 2)}".rjust(10))
if self._dados[4] != 0:
linha += f" {self._dados[4]}"
linha += "\n"
arq.write(linha)
[documentos]class FT(RegistroDecomp):
"""
Registro que contém os coeficientes das usinas térmicas
nas restrições elétricas.
"""
mnemonico = "FT"
def __init__(self):
super().__init__(FT.mnemonico, True)
self._dados = [0, 0, 0, 0, 0.0]
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(2)
reg_ute = RegistroIn(3)
reg_subsis = RegistroIn(2)
reg_fator = RegistroFn(10)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
self._dados[2] = reg_ute.le_registro(self._linha, 14)
self._dados[3] = reg_subsis.le_registro(self._linha, 19)
self._dados[4] = reg_fator.le_registro(self._linha, 24)
def escreve(self, arq: IO):
linha = (f"{FT.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".rjust(3) + " " +
f"{self._dados[3]}".rjust(2) + " " +
f"{round(self._dados[4], 2)}".rjust(10))
linha += "\n"
arq.write(linha)
[documentos]class FI(RegistroDecomp):
"""
Registro que contém o sentido do fluxo da interligação
entre os subsistemas associados à restrição elétrica.
"""
mnemonico = "FI"
def __init__(self):
super().__init__(FI.mnemonico, True)
self._dados = [0, 0, "", "", 0.0]
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(2)
reg_subsis = RegistroAn(2)
reg_fator = RegistroFn(10)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
self._dados[2] = reg_subsis.le_registro(self._linha, 14)
self._dados[3] = reg_subsis.le_registro(self._linha, 19)
self._dados[4] = reg_fator.le_registro(self._linha, 24)
def escreve(self, arq: IO):
linha = (f"{FI.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".rjust(2) + " " +
f"{self._dados[3]}".rjust(2) + " " +
f"{round(self._dados[4], 2)}".rjust(10))
linha += "\n"
arq.write(linha)
[documentos]class VI(RegistroDecomp):
"""
Registro que contém os tempos de viagem da água entre usinas.
"""
mnemonico = "VI"
def __init__(self):
super().__init__(VI.mnemonico, True)
self._dados = [0, 0]
def le(self):
reg_usi = RegistroIn(3)
reg_dur = RegistroIn(3)
reg_tempo = RegistroFn(5)
self._dados[0] = reg_usi.le_registro(self._linha, 4)
self._dados[1] = reg_dur.le_registro(self._linha, 9)
ci = 14
for i in range(24):
cf = ci + 5
if len(self._linha[ci:cf].strip()) == 0:
break
self._dados.append(reg_tempo.le_registro(self._linha, ci))
ci = cf
def escreve(self, arq: IO):
linha = (f"{VI.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(3) + " ")
for i in range(2, len(self._dados)):
a_escrever = f"{round(self._dados[i], 2)}".rjust(5)
if len(a_escrever) > 5:
a_escrever = f"{round(self._dados[i], 1)}".rjust(5)
if len(a_escrever) > 5:
a_escrever = f"{int(self._dados[i])}".rjust(5)
linha += a_escrever
linha += "\n"
arq.write(linha)
@property
def uhe(self) -> int:
"""
O código da UHE a partir do qual é contabilizado
o tempo de viagem.
:return: O código como `int`
"""
return self._dados[0]
@property
def duracao(self) -> int:
"""
A duração da viagem da água (em horas) entre a UHE do
código informado e sua usina à jusante segundo o hidr.
:return: A duração como `int`
"""
return self._dados[1]
@duracao.setter
def duracao(self, d: int):
self._dados[1] = d
@property
def vazoes(self) -> List[float]:
"""
As vazões defluentes das semanas passadas para a usina
do código informado. A posição da vazão na lista indica
a qual semana passada se refere [s-1, s-2, s-3, ...].
:return: A duração como `int`
"""
return self._dados[2:]
@vazoes.setter
def vazoes(self, v: List[float]):
novos = len(v)
atuais = len(self.vazoes)
if novos != atuais:
raise ValueError("Número de vazões incompatível. De" +
f"vem ser fornecidos {atuais}, mas foram {novos}")
self._dados[2:] = v
class ACNUMPOS(TipoRegistroAC):
"""
Registro AC específico para alteração no número do posto.
"""
mnemonico = "NUMPOS"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0
def le(self):
reg_usi = RegistroIn(5)
self._dados = reg_usi.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{self._dados}".rjust(5)
return linha
class ACNUMJUS(TipoRegistroAC):
"""
Registro AC específico para alteração na usina de jusante.
"""
mnemonico = "NUMJUS"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0
def le(self):
reg_usi = RegistroIn(5)
self._dados = reg_usi.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{self._dados}".rjust(5)
return linha
class ACDESVIO(TipoRegistroAC):
"""
Registro AC específico para alteração na usina de jusante
para canal de desvio e limite da vazão no canal.
"""
mnemonico = "DESVIO"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = [0, 0.0]
def le(self):
reg_usi = RegistroIn(5)
reg_desvio = RegistroFn(10)
self._dados[0] = reg_usi.le_registro(self._linha, 19)
self._dados[1] = reg_desvio.le_registro(self._linha, 24)
@property
def linha_escrita(self) -> str:
linha = (f"{self._dados[0]}".rjust(5) +
f"{round(self._dados[1], 2)}".rjust(10))
return linha
class ACVOLMIN(TipoRegistroAC):
"""
Registro AC específico para alteração na usina de jusante
para canal de desvio e limite da vazão no canal.
"""
mnemonico = "VOLMIN"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0.0
def le(self):
reg_desvio = RegistroFn(10)
self._dados = reg_desvio.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{round(self._dados, 2)}".rjust(10)
return linha
class ACVOLMAX(TipoRegistroAC):
"""
Registro AC específico para alteração na usina de jusante
para canal de desvio e limite da vazão no canal.
"""
mnemonico = "VOLMAX"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0.0
def le(self):
reg_desvio = RegistroFn(10)
self._dados = reg_desvio.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{round(self._dados, 2)}".rjust(10)
return linha
class ACCOTVOL(TipoRegistroAC):
"""
Registro AC específico para alteração de um coeficiente do
polinômio cota-volume.
"""
mnemonico = "COTVOL"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = [0, 0.0]
def le(self):
reg_indice = RegistroIn(5)
reg_coef = RegistroFn(15)
self._dados[0] = reg_indice.le_registro(self._linha, 19)
self._dados[1] = reg_coef.le_registro(self._linha, 24)
@property
def linha_escrita(self) -> str:
linha = (f"{self._dados[0]}".rjust(5) +
f"{round(self._dados[1], 3)}".rjust(15))
return linha
class ACCOTARE(TipoRegistroAC):
"""
Registro AC específico para alteração de um coeficiente do
polinômio cota-área.
"""
mnemonico = "COTARE"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = [0, 0.0]
def le(self):
reg_indice = RegistroIn(5)
reg_coef = RegistroFn(15)
self._dados[0] = reg_indice.le_registro(self._linha, 19)
self._dados[1] = reg_coef.le_registro(self._linha, 24)
@property
def linha_escrita(self) -> str:
linha = (f"{self._dados[0]}".rjust(5) +
f"{round(self._dados[1], 3)}".rjust(15))
return linha
class ACPROESP(TipoRegistroAC):
"""
Registro AC específico para alteração do coeficiente de perdas
hidráulicas em função da queda bruta (%,m,k).
"""
mnemonico = "PROESP"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0.0
def le(self):
reg_desvio = RegistroFn(10)
self._dados = reg_desvio.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{round(self._dados, 2)}".rjust(10)
return linha
class ACPERHID(TipoRegistroAC):
"""
Registro AC específico para alteração do coeficiente de perdas
hidráulicas em função da queda bruta (%,m,k).
"""
mnemonico = "PERHID"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0.0
def le(self):
reg_desvio = RegistroFn(10)
self._dados = reg_desvio.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{round(self._dados, 2)}".rjust(10)
return linha
class ACNCHAVE(TipoRegistroAC):
"""
Registro AC específico para alteração do número da curva-chave
(cota-vazão) e nível de jusante da faixa associada (m).
"""
mnemonico = "NCHAVE"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = [0, 0.0]
def le(self):
reg_usi = RegistroIn(5)
reg_desvio = RegistroFn(10)
self._dados[0] = reg_usi.le_registro(self._linha, 19)
self._dados[1] = reg_desvio.le_registro(self._linha, 24)
@property
def linha_escrita(self) -> str:
linha = (f"{self._dados[0]}".rjust(5) +
f"{round(self._dados[1], 1)}".rjust(10))
return linha
class ACCOTVAZ(TipoRegistroAC):
"""
Registro AC específico para alteração de um coeficiente do
polinômio cota-vazão.
"""
mnemonico = "COTVAZ"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = [0, 0, 0.0]
def le(self):
reg_indice = RegistroIn(5)
reg_coef = RegistroFn(15)
self._dados[0] = reg_indice.le_registro(self._linha, 19)
self._dados[1] = reg_indice.le_registro(self._linha, 24)
self._dados[2] = reg_coef.le_registro(self._linha, 29)
@property
def linha_escrita(self) -> str:
linha = (f"{self._dados[0]}".rjust(5) +
f"{self._dados[1]}".rjust(5) +
f"{round(self._dados[2], 3)}".rjust(15))
return linha
class ACCOFEVA(TipoRegistroAC):
"""
Registro AC específico para alteração do coeficiente de evaporação
mensal para cada mês.
"""
mnemonico = "COFEVA"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = [0, 0]
def le(self):
reg_mes = RegistroIn(5)
self._dados = reg_mes.le_linha_tabela(self._linha, 19, 0, 2)
@property
def linha_escrita(self) -> str:
linha = (f"{self._dados[0]}".rjust(5) +
f"{self._dados[1]}".rjust(5))
return linha
class ACNUMCON(TipoRegistroAC):
"""
Registro AC específico para alteração no número de conjuntos
de máquinas.
"""
mnemonico = "NUMCON"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0
def le(self):
reg_usi = RegistroIn(5)
self._dados = reg_usi.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{self._dados}".rjust(5)
return linha
class ACNUMMAQ(TipoRegistroAC):
"""
Registro AC específico para alteração do número de máquinas
em cada conjunto de máquinas.
"""
mnemonico = "NUMMAQ"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = [0, 0]
def le(self):
reg_mes = RegistroIn(5)
self._dados = reg_mes.le_linha_tabela(self._linha, 19, 0, 2)
@property
def linha_escrita(self) -> str:
linha = (f"{self._dados[0]}".rjust(5) +
f"{self._dados[1]}".rjust(5))
return linha
class ACPOTEFE(TipoRegistroAC):
"""
Registro AC específico para alteração da potência efetiva
por unidade geradora em um conjunto de máquinas.
"""
mnemonico = "POTEFE"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = [0, 0.0]
def le(self):
reg_usi = RegistroIn(5)
reg_desvio = RegistroFn(10)
self._dados[0] = reg_usi.le_registro(self._linha, 19)
self._dados[1] = reg_desvio.le_registro(self._linha, 24)
@property
def linha_escrita(self) -> str:
linha = (f"{self._dados[0]}".rjust(5) +
f"{round(self._dados[1], 1)}".rjust(10))
return linha
class ACALTEFE(TipoRegistroAC):
"""
Registro AC específico para alteração da altura efetiva
de queda para um conjunto de máquinas.
"""
mnemonico = "ALTEFE"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = [0, 0.0]
def le(self):
reg_usi = RegistroIn(5)
reg_desvio = RegistroFn(10)
self._dados[0] = reg_usi.le_registro(self._linha, 19)
self._dados[1] = reg_desvio.le_registro(self._linha, 24)
@property
def linha_escrita(self) -> str:
linha = (f"{self._dados[0]}".rjust(5) +
f"{round(self._dados[1], 1)}".rjust(10))
return linha
class ACVAZEFE(TipoRegistroAC):
"""
Registro AC específico para alteração da vazão efetiva
para um conjunto de máquinas.
"""
mnemonico = "VAZEFE"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = [0, 0]
def le(self):
reg_usi = RegistroIn(5)
reg_vaz = RegistroIn(5)
self._dados[0] = reg_usi.le_registro(self._linha, 19)
self._dados[1] = reg_vaz.le_registro(self._linha, 24)
@property
def linha_escrita(self) -> str:
linha = (f"{self._dados[0]}".rjust(5) +
f"{self._dados[1]}".rjust(5))
return linha
class ACJUSMED(TipoRegistroAC):
"""
Registro AC específico para alteração da cota média do canal
de fuga em metros.
"""
mnemonico = "JUSMED"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0.0
def le(self):
reg_desvio = RegistroFn(10)
self._dados = reg_desvio.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{round(self._dados, 2)}".rjust(10)
return linha
class ACVERTJU(TipoRegistroAC):
"""
Registro AC específico para alteração da influência do vertimento
na cota do canal de fuga.
"""
mnemonico = "VERTJU"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0
def le(self):
reg_usi = RegistroIn(5)
self._dados = reg_usi.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{self._dados}".rjust(5)
return linha
class ACVAZMIN(TipoRegistroAC):
"""
Registro AC específico para alteração da vazão mínima histórica.
"""
mnemonico = "VAZMIN"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = -1
def le(self):
reg_usi = RegistroIn(5)
if len(self._linha[19:24].strip()) > 0:
self._dados = reg_usi.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
if self._dados != -1:
linha = f"{self._dados}".rjust(5)
else:
linha = "".rjust(5)
return linha
class ACTIPERH(TipoRegistroAC):
"""
Registro AC específico para alteração do tipo de perdas hidráulicas.
"""
mnemonico = "TIPERH"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = -1
def le(self):
reg_usi = RegistroIn(5)
if len(self._linha[19:24].strip()) > 0:
self._dados = reg_usi.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
if self._dados != -1:
linha = f"{self._dados}".rjust(5)
else:
linha = "".rjust(5)
return linha
class ACJUSENA(TipoRegistroAC):
"""
Registro AC específico para alteração do índice de
aproveitamento de jusante para cálculo das energias
armazenada e afluente.
"""
mnemonico = "JUSENA"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0
def le(self):
reg_usi = RegistroIn(5)
self._dados = reg_usi.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{self._dados}".rjust(5)
return linha
class ACVSVERT(TipoRegistroAC):
"""
Registro AC específico para alteração do volume mínimo para operação
do vertedor.
"""
mnemonico = "VSVERT"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0.0
def le(self):
reg_desvio = RegistroFn(10)
self._dados = reg_desvio.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{round(self._dados, 2)}".rjust(10)
return linha
class ACVMDESV(TipoRegistroAC):
"""
Registro AC específico para alteração do volume mínimo para operação
do canal de desvio.
"""
mnemonico = "VMDESV"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0.0
def le(self):
reg_desvio = RegistroFn(10)
self._dados = reg_desvio.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{round(self._dados, 2)}".rjust(10)
return linha
class ACNPOSNW(TipoRegistroAC):
"""
Registro AC específico para alteração do posto de acoplamento
com o NEWAVE.
"""
mnemonico = "NPOSNW"
def __init__(self, linha: str):
super().__init__(linha)
self._dados = 0
def le(self):
reg_usi = RegistroIn(5)
self._dados = reg_usi.le_registro(self._linha, 19)
@property
def linha_escrita(self) -> str:
linha = f"{self._dados}".rjust(5)
return linha
[documentos]class AC(RegistroDecomp):
"""
Registro que contém as alterações de cadastro das usinas hidrelétricas.
"""
mnemonico = "AC"
modificacoes: List[Type[TipoRegistroAC]] = [
ACNUMPOS,
ACNUMJUS,
ACDESVIO,
ACVOLMIN,
ACVOLMAX,
ACCOTVOL,
ACCOTARE,
ACPROESP,
ACPERHID,
ACNCHAVE,
ACCOTVAZ,
ACCOFEVA,
ACNUMCON,
ACNUMMAQ,
ACPOTEFE,
ACALTEFE,
ACVAZEFE,
ACJUSMED,
ACVERTJU,
ACVAZMIN,
ACTIPERH,
ACJUSENA,
ACVSVERT,
ACVMDESV,
ACNPOSNW
]
def __init__(self):
super().__init__(AC.mnemonico, True)
self._dados = [0, "", "", 0, 0]
self._modificacao: TipoRegistroAC = None
def le(self):
def procura_modificacao() -> TipoRegistroAC:
for m in AC.modificacoes:
if m.mnemonico == self._dados[1]:
return m(self._linha)
raise ValueError(f"Mnemônico {self._dados[1]} não" +
" suportado para registro AC")
reg_usi = RegistroIn(3)
reg_cod = RegistroAn(6)
reg_mes = RegistroAn(3)
reg_semana = RegistroIn(1)
reg_ano = RegistroIn(4)
self._dados[0] = reg_usi.le_registro(self._linha, 4)
self._dados[1] = reg_cod.le_registro(self._linha, 9)
if len(self._linha[69:72].strip()) == 3:
self._dados[2] = reg_mes.le_registro(self._linha, 69)
if self._linha[74:75].isnumeric():
self._dados[3] = reg_semana.le_registro(self._linha, 74)
if self._linha[76:80].isnumeric():
self._dados[4] = reg_ano.le_registro(self._linha, 76)
# Procura a modificação pelo mnemônico
self._modificacao = procura_modificacao()
# Faz a leitura segundo a lógica específica
self._modificacao.le()
def escreve(self, arq: IO):
linha = (f"{AC.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(6))
linha = linha.ljust(19)
linha += self._modificacao.linha_escrita
if any([
self._dados[2] != "",
self._dados[3] != 0,
self._dados[4] != 0
]):
linha = linha.ljust(69)
linha += self._dados[2]
linha = linha.ljust(74)
if self._dados[3] != 0:
linha += f"{self._dados[3]}"
linha = linha.ljust(76)
if self._dados[4] != 0:
linha += f"{self._dados[4]}"
linha += "\n"
arq.write(linha)
@property
def uhe(self) -> int:
return self._dados[0]
@uhe.setter
def uhe(self, u: int):
self._dados[0] = u
@property
def modificacao(self) -> str:
return self._dados[1]
@modificacao.setter
def modificacao(self, m: str):
self._dados[1] = m
@property
def mes(self) -> str:
return self._dados[2]
@mes.setter
def mes(self, m: str):
self._dados[2] = m
@property
def semana(self) -> int:
return self._dados[3]
@semana.setter
def semana(self, s: int):
self._dados[3] = s
@property
def ano(self) -> int:
return self._dados[4]
@ano.setter
def ano(self, m: int):
self._dados[4] = m
[documentos]class IR(RegistroDecomp):
"""
Registro que contém as configurações de
geração de relatórios de saída.
"""
mnemonico = "IR"
def __init__(self):
super().__init__(IR.mnemonico, True)
self._dados = ["", 0, 0, 0]
def le(self):
reg_mne = RegistroAn(7)
reg_op1 = RegistroIn(2)
reg_op2 = RegistroIn(2)
reg_op3 = RegistroIn(5)
self._dados[0] = reg_mne.le_registro(self._linha, 4)
if self._linha[14:16].strip().isnumeric():
self._dados[1] = reg_op1.le_registro(self._linha, 14)
if self._linha[19:21].strip().isnumeric():
self._dados[2] = reg_op2.le_registro(self._linha, 19)
if self._linha[24:29].strip().isnumeric():
self._dados[3] = reg_op3.le_registro(self._linha, 24)
def escreve(self, arq: IO):
linha = (f"{IR.mnemonico}".ljust(4) +
f"{self._dados[0]}".ljust(7))
if self._dados[1] != 0:
linha += " " + f"{self._dados[1]}".zfill(2)
if self._dados[2] != 0:
linha = linha.ljust(19)
linha += f"{self._dados[2]}".rjust(2)
if self._dados[3] != 0:
linha = linha.ljust(24)
linha += f"{self._dados[3]}".rjust(5)
linha += "\n"
arq.write(linha)
@property
def tipo(self) -> str:
"""
Mnemônico que contém o tipo de relatório de
saída escolhido.
:return: O mnemônico como `str`.
"""
return self._dados[0]
[documentos]class CI(RegistroDecomp):
"""
Registro que define contratos de importação de energia.
"""
mnemonico = "CI"
def __init__(self):
super().__init__(CI.mnemonico, True)
self._dados = [0, 0, "", 0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0,
0.0]
def le(self):
reg_contrato = RegistroIn(3)
reg_subsis = RegistroIn(2)
reg_nome = RegistroAn(10)
reg_estagio = RegistroIn(2)
reg_limite = RegistroFn(5)
reg_custo = RegistroFn(10)
reg_fator = RegistroFn(5)
self._dados[0] = reg_contrato.le_registro(self._linha, 4)
self._dados[1] = reg_subsis.le_registro(self._linha, 8)
self._dados[2] = reg_nome.le_registro(self._linha, 11)
self._dados[3] = reg_estagio.le_registro(self._linha, 24)
for i in range(3):
self._dados[4 + i * 3] = reg_limite.le_registro(self._linha,
29 + i * 20)
self._dados[5 + i * 3] = reg_limite.le_registro(self._linha,
34 + i * 20)
self._dados[6 + i * 3] = reg_custo.le_registro(self._linha,
39 + i * 20)
if self._linha[89:94].strip().isnumeric():
self._dados[13] = reg_fator.le_registro(self._linha, 89)
def escreve(self, arq: IO):
linha = (f"{CI.mnemonico}".ljust(4) +
f"{self._dados[0]}".zfill(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".ljust(10) + " " +
f"{self._dados[3]}".rjust(2) + " ")
for i in range(3):
linha += f"{round(self._dados[4 + i * 3], 1)}".rjust(5)
linha += f"{round(self._dados[5 + i * 3], 1)}".rjust(5)
linha += f"{round(self._dados[6 + i * 3], 2)}".rjust(10)
if self._dados[13] != 0.0:
linha += f"{round(self._dados[13], 2)}".rjust(5)
linha += "\n"
arq.write(linha)
[documentos]class CE(RegistroDecomp):
"""
Registro que define contratos de importação de energia.
"""
mnemonico = "CE"
def __init__(self):
super().__init__(CE.mnemonico, True)
self._dados = [0, 0, "", 0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0,
0.0]
def le(self):
reg_contrato = RegistroIn(3)
reg_subsis = RegistroIn(2)
reg_nome = RegistroAn(10)
reg_estagio = RegistroIn(2)
reg_limite = RegistroFn(5)
reg_custo = RegistroFn(10)
reg_fator = RegistroFn(5)
self._dados[0] = reg_contrato.le_registro(self._linha, 4)
self._dados[1] = reg_subsis.le_registro(self._linha, 8)
self._dados[2] = reg_nome.le_registro(self._linha, 11)
self._dados[3] = reg_estagio.le_registro(self._linha, 24)
for i in range(3):
self._dados[4 + i * 3] = reg_limite.le_registro(self._linha,
29 + i * 20)
self._dados[5 + i * 3] = reg_limite.le_registro(self._linha,
34 + i * 20)
self._dados[6 + i * 3] = reg_custo.le_registro(self._linha,
39 + i * 20)
if self._linha[89:94].strip().isnumeric():
self._dados[13] = reg_fator.le_registro(self._linha, 89)
def escreve(self, arq: IO):
linha = (f"{CE.mnemonico}".ljust(4) +
f"{self._dados[0]}".zfill(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".ljust(10) + " " +
f"{self._dados[3]}".rjust(2) + " ")
for i in range(3):
linha += f"{round(self._dados[4 + i * 3], 1)}".rjust(5)
linha += f"{round(self._dados[5 + i * 3], 1)}".rjust(5)
linha += f"{round(self._dados[6 + i * 3], 2)}".rjust(10)
if self._dados[13] != 0.0:
linha += f"{round(self._dados[13], 2)}".rjust(5)
linha += "\n"
arq.write(linha)
[documentos]class FC(RegistroDecomp):
"""
Registro que contém informações para acessar a FCF fornecida
pelo NEWAVE.
"""
mnemonico = "FC"
def __init__(self):
super().__init__(FC.mnemonico, True)
self._dados = ["", ""]
def le(self):
reg_mne = RegistroAn(6)
reg_nome = RegistroAn(200)
self._dados[0] = reg_mne.le_registro(self._linha, 4)
self._dados[1] = reg_nome.le_registro(self._linha, 14)
def escreve(self, arq: IO):
linha = (f"{FC.mnemonico}".ljust(4) +
f"{self._dados[0]}".ljust(6) + " " +
self._dados[1] + "\n")
arq.write(linha)
@property
def tipo(self) -> str:
"""
O tipo de arquivo da FCF na forma dos mnemônicos
aceitos pelo DECOMP.
:return: O mnemônico como `str`.
"""
return self._dados[0]
@property
def caminho(self) -> str:
"""
O caminho relativo ou completo para o arquivo da
FCF.
:return: O caminho como `str`.
"""
return self._dados[1]
@caminho.setter
def caminho(self, c: str):
self._dados[1] = c
[documentos]class RT(RegistroDecomp):
"""
Registro utilizado para retirada de restrições de soleira de
vertedouro e de canais de desvio.
"""
mnemonico = "RT"
def __init__(self):
super().__init__(RT.mnemonico, True)
self._dados = [""]
def le(self):
reg_mne = RegistroAn(6)
self._dados[0] = reg_mne.le_registro(self._linha, 4)
def escreve(self, arq: IO):
linha = (f"{RT.mnemonico}".ljust(4) +
f"{self._dados[0]}".ljust(6) + "\n")
arq.write(linha)
@property
def restricao(self) -> str:
"""
O mnemônico da restrição removida.
:return: O mnemônico como `str`.
"""
return self._dados[0]
@restricao.setter
def restricao(self, m: str):
self._dados[0] = m
[documentos]class TI(RegistroDecomp):
"""
Registro que contém as taxas de irrigação por UHE.
"""
mnemonico = "TI"
def __init__(self):
super().__init__(TI.mnemonico, True)
self._dados = [0]
def le(self):
reg_uhe = RegistroIn(3)
reg_irrig = RegistroFn(5)
self._dados[0] = reg_uhe.le_registro(self._linha, 4)
ci = 9
for i in range(24):
cf = ci + 5
if len(self._linha[ci:cf].strip()) == 0:
break
self._dados.append(reg_irrig.le_registro(self._linha, ci))
ci = cf
def escreve(self, arq: IO):
linha = (f"{TI.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " ")
for i in range(1, len(self._dados)):
# Verificação de segurança para tamanho do registro
a_escrever = f"{round(self._dados[i], 2)}".rjust(5)
if len(a_escrever) > 5:
a_escrever = f"{round(self._dados[i], 1)}".rjust(5)
if len(a_escrever) > 5:
a_escrever = f"{int(self._dados[i])}".rjust(5)
linha += a_escrever
linha += "\n"
arq.write(linha)
@property
def codigo(self) -> int:
"""
O código da UHE associada às taxas de irrigação
:return: O código como `int`.
"""
return self._dados[0]
@property
def taxas(self) -> List[float]:
"""
As taxas de irrigação por estágio do estudo. A
posição da taxa na lista indica a qual estágio
ela está associada [e1, e2, e3, ...].
:return: As taxas como `list[float]`.
"""
return self._dados[1:]
@taxas.setter
def taxas(self, tx: List[float]):
novas = len(tx)
atuais = len(self.taxas)
if novas != atuais:
raise ValueError("Número de taxas incompatível. De" +
f"vem ser fornecidas {atuais}, mas foram {novas}")
self._dados[1:] = tx
class FP(RegistroDecomp):
"""
Registro que contém os cadastros de restrições de alteração na
função de produção das usinas.
"""
mnemonico = "FP"
def __init__(self):
super().__init__(FP.mnemonico, True)
self._dados = [0, 0, 0, 0, 0.0, 0.0, 0, 0, 0.0, 0.0]
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(3)
reg_flag = RegistroIn(1)
reg_pontos = RegistroIn(4)
reg_limite = RegistroFn(5)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
self._dados[2] = reg_flag.le_registro(self._linha, 14)
self._dados[3] = reg_pontos.le_registro(self._linha, 16)
self._dados[4] = reg_limite.le_registro(self._linha, 21)
self._dados[5] = reg_limite.le_registro(self._linha, 27)
self._dados[6] = reg_flag.le_registro(self._linha, 34)
self._dados[7] = reg_pontos.le_registro(self._linha, 36)
if len(self._linha[41:46].strip()) > 0:
self._dados[8] = reg_limite.le_registro(self._linha, 41)
if len(self._linha[47:52].strip()) > 0:
self._dados[9] = reg_limite.le_registro(self._linha, 47)
def escreve(self, arq: IO):
linha = (f"{FP.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(3) + " " +
f"{self._dados[2]}" + " " +
f"{self._dados[3]}".rjust(4) + " " +
f"{self._dados[4]:.1f}".rjust(5) + " " +
f"{self._dados[5]:.1f}".rjust(5) + " " +
f"{self._dados[6]}" + " " +
f"{self._dados[7]}".rjust(4))
if self._dados[8] != 0:
linha += " " + f"{self._dados[8]:.1f}".rjust(5)
if self._dados[9] != 0:
linha += " " + f"{self._dados[9]:.1f}".rjust(5)
linha += "\n"
arq.write(linha)
@property
def codigo(self) -> int:
"""
O código da UHE associada à restrição FP.
:return: O código como `int`.
"""
return self._dados[0]
@codigo.setter
def codigo(self, c: int):
self._dados[0] = c
@property
def estagio(self) -> int:
"""
O estágio associado à restrição FP.
:return: O estágio como `int`.
"""
return self._dados[1]
@estagio.setter
def estagio(self, e: int):
self._dados[1] = e
@property
def tipo_entrada_janela_turbinamento(self) -> int:
"""
O tipo de entrada da janela de turbinamento fornecido
na restrição FP. 0 para limites em percentual da vazão turbinada
máxima das usinas, 1 para limites em m3/s.
:return: O tipo de entrada como `int`.
"""
return self._dados[2]
@tipo_entrada_janela_turbinamento.setter
def tipo_entrada_janela_turbinamento(self, t: int):
self._dados[2] = t
@property
def numero_pontos_turbinamento(self) -> int:
"""
O número de pontos para discretização da janela de
turbinamento. Máximo permitido de 1000 pontos.
:return: O número de pontos como `int`.
"""
return self._dados[3]
@numero_pontos_turbinamento.setter
def numero_pontos_turbinamento(self, n: int):
self._dados[3] = n
@property
def limite_inferior_janela_turbinamento(self) -> float:
"""
O limite inferior da janela de turbinamento.
:return: O limite como `float`.
"""
return self._dados[4]
@limite_inferior_janela_turbinamento.setter
def limite_inferior_janela_turbinamento(self, lim: float):
self._dados[4] = lim
@property
def limite_superior_janela_turbinamento(self) -> float:
"""
O limite superior da janela de turbinamento.
:return: O limite como `float`.
"""
return self._dados[5]
@limite_superior_janela_turbinamento.setter
def limite_superior_janela_turbinamento(self, lim: float):
self._dados[5] = lim
@property
def tipo_entrada_janela_volume(self) -> int:
"""
O tipo de entrada da janela de volume fornecido
na restrição FP. 0 para limites em percentual do volume útil
das usinas, 1 para limites em hm3.
:return: O tipo de entrada como `int`.
"""
return self._dados[6]
@tipo_entrada_janela_volume.setter
def tipo_entrada_janela_volume(self, t: int):
self._dados[6] = t
@property
def numero_pontos_volume(self) -> int:
"""
O número de pontos para discretização da janela de
volume. Máximo permitido de 1000 pontos.
:return: O número de pontos como `int`.
"""
return self._dados[7]
@numero_pontos_volume.setter
def numero_pontos_volume(self, n: int):
self._dados[7] = n
@property
def limite_inferior_janela_volume(self) -> float:
"""
A redução aplicada ao volume útil da usina, para ser utilizado
como limite inferior da janela de volume.
:return: O limite como `float`.
"""
return self._dados[8]
@limite_inferior_janela_volume.setter
def limite_inferior_janela_volume(self, lim: float):
self._dados[8] = lim
@property
def limite_superior_janela_volume(self) -> float:
"""
O acréscimo aplicado ao volume útil da usina, para ser utilizado
como limite superior da janela de volume.
:return: O limite como `float`.
"""
return self._dados[9]
@limite_superior_janela_volume.setter
def limite_superior_janela_volume(self, lim: float):
self._dados[9] = lim
[documentos]class RQ(RegistroDecomp):
"""
Registro que contém os percentuais de vazão defluente
mínima histórica para cada REE.
"""
mnemonico = "RQ"
def __init__(self):
super().__init__(RQ.mnemonico, True)
self._dados = [0]
def le(self):
reg_ree = RegistroIn(2)
reg_vazao = RegistroFn(5)
self._dados[0] = reg_ree.le_registro(self._linha, 4)
ci = 9
for i in range(24):
cf = ci + 5
if len(self._linha[ci:cf].strip()) == 0:
break
self._dados.append(reg_vazao.le_registro(self._linha, ci))
ci = cf
def escreve(self, arq: IO):
linha = (f"{RQ.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(2) + " ")
for i in range(1, len(self._dados)):
linha += f"{round(self._dados[i], 2)}".rjust(5)
linha += "\n"
arq.write(linha)
@property
def ree(self) -> int:
"""
O código do REE associado às vazões mínimas.
:return: O código como `int`.
"""
return self._dados[0]
@ree.setter
def ree(self, r: int):
self._dados[0] = r
@property
def vazoes(self) -> List[float]:
"""
As vazões defluentes mínimas (percentuais)
para o REE, por estágio [e1, e2, e3, ...].
:return: As vazoes como `list[float]`.
"""
return self._dados[1:]
@vazoes.setter
def vazoes(self, tx: List[float]):
novas = len(tx)
atuais = len(self.vazoes)
if novas != atuais:
raise ValueError("Número de vazões incompatível. De" +
f"vem ser fornecidas {atuais}, mas foram {novas}")
self._dados[1:] = tx
[documentos]class EZ(RegistroDecomp):
"""
Registro que contém o percentual máximo do
volume útil para acoplamento.
"""
mnemonico = "EZ"
def __init__(self):
super().__init__(EZ.mnemonico, True)
self._dados = [0, 0.0]
def le(self):
reg_uhe = RegistroIn(3)
reg_volume = RegistroFn(5)
self._dados[0] = reg_uhe.le_registro(self._linha, 4)
self._dados[1] = reg_volume.le_registro(self._linha, 9)
def escreve(self, arq: IO):
linha = (f"{EZ.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{round(self._dados[1], 2)}".rjust(5) + "\n")
arq.write(linha)
[documentos]class HV(RegistroDecomp):
"""
Registro que contém os cadastros de restrições de volume armazenado.
"""
mnemonico = "HV"
def __init__(self):
super().__init__(HV.mnemonico, True)
self._dados = [0, 0, 0]
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(2)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
self._dados[2] = reg_estagio.le_registro(self._linha, 14)
def escreve(self, arq: IO):
linha = (f"{HV.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".rjust(2) + "\n")
arq.write(linha)
@property
def codigo(self) -> int:
"""
O código da UHE associada à restrição HV.
:return: O código como `int`.
"""
return self._dados[0]
@property
def estagio_inicial(self) -> int:
"""
O estágio inicial de consideração da restrição HV.
:return: O estágio como `int`.
"""
return self._dados[1]
@property
def estagio_final(self) -> int:
"""
O estágio final de consideração da restrição HV.
:return: O estágio como `int`.
"""
return self._dados[2]
[documentos]class LV(RegistroDecomp):
"""
Registro que contém os limites das restrições de volume armazenado.
"""
mnemonico = "LV"
default = 1e21
def __init__(self):
super().__init__(LV.mnemonico, True)
self._dados = [0, 0] + [LV.default] * 2
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(2)
reg_limite = RegistroFn(10)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
ci = 14
for i in range(2, len(self._dados)):
cf = ci + 10
if len(self._linha[ci:cf].strip()) != 0:
self._dados[i] = reg_limite.le_registro(self._linha, ci)
ci = cf
def escreve(self, arq: IO):
linha = (f"{LV.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " ")
for i in range(2, len(self._dados)):
if self._dados[i] != LV.default:
linha += f"{round(self._dados[i], 2)}".rjust(10)
else:
linha += " "
arq.write(linha + "\n")
@property
def codigo(self) -> int:
"""
O código da restrição HV associada aos limites
:return: O código como `int`.
"""
return self._dados[0]
@property
def estagio(self) -> int:
"""
O estágio de consideração dos limites.
:return: O estágio como `int`.
"""
return self._dados[1]
@estagio.setter
def estagio(self, e: int):
self._dados[1] = e
@property
def limite_inferior(self) -> float:
"""
O limite inferior para o armazenamento.
:return: O limite como `float`.
"""
return self._dados[2]
@limite_inferior.setter
def limite_inferior(self, lim: float):
self._dados[2] = lim
@property
def limites_superior(self) -> float:
"""
O limite superior para o armazenamento.
:return: O limite como `float`.
"""
return self._dados[3]
@limites_superior.setter
def limites_superior(self, lim: float):
self._dados[3] = lim
[documentos]class CV(RegistroDecomp):
"""
Registro que contém os coeficientes das usinas hidráulicas
nas restrições de volume armazenado.
"""
mnemonico = "CV"
def __init__(self):
super().__init__(CV.mnemonico, True)
self._dados = [0, 0, 0, 0.0, ""]
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(2)
reg_uhe = RegistroIn(3)
reg_fator = RegistroFn(10)
reg_tipo = RegistroAn(4)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
self._dados[2] = reg_uhe.le_registro(self._linha, 14)
self._dados[3] = reg_fator.le_registro(self._linha, 19)
self._dados[4] = reg_tipo.le_registro(self._linha, 34)
def escreve(self, arq: IO):
linha = (f"{CV.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".rjust(3) + " " +
f"{round(self._dados[3], 8)}".rjust(10))
linha = linha.ljust(34)
linha += self._dados[4]
linha += "\n"
arq.write(linha)
[documentos]class HQ(RegistroDecomp):
"""
Registro que contém os cadastros de restrições de vazões.
"""
mnemonico = "HQ"
def __init__(self):
super().__init__(HQ.mnemonico, True)
self._dados = [0, 0, 0]
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(2)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
self._dados[2] = reg_estagio.le_registro(self._linha, 14)
def escreve(self, arq: IO):
linha = (f"{HQ.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".rjust(2) + "\n")
arq.write(linha)
@property
def codigo(self) -> int:
"""
O código da UHE associada à restrição HQ.
:return: O código como `int`.
"""
return self._dados[0]
@property
def estagio_inicial(self) -> int:
"""
O estágio inicial de consideração da restrição HQ.
:return: O estágio como `int`.
"""
return self._dados[1]
@property
def estagio_final(self) -> int:
"""
O estágio final de consideração da restrição HQ.
:return: O estágio como `int`.
"""
return self._dados[2]
[documentos]class LQ(RegistroDecomp):
"""
Registro que contém os limites das restrições de volume armazenado.
"""
mnemonico = "LQ"
default = 1e21
def __init__(self):
super().__init__(LQ.mnemonico, True)
self._dados = [0, 0] + [LQ.default] * 6
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(2)
reg_limite = RegistroFn(10)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
ci = 14
for i in range(2, len(self._dados)):
cf = ci + 10
if len(self._linha[ci:cf].strip()) != 0:
self._dados[i] = reg_limite.le_registro(self._linha, ci)
ci = cf
def escreve(self, arq: IO):
linha = (f"{LQ.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " ")
for i in range(2, len(self._dados)):
if self._dados[i] != LQ.default:
linha += f"{round(self._dados[i], 2)}".rjust(10)
else:
linha += " "
arq.write(linha + "\n")
@property
def codigo(self) -> int:
"""
O código da restrição HQ associada aos limites
:return: O código como `int`.
"""
return self._dados[0]
@property
def estagio(self) -> int:
"""
O estágio de consideração dos limites.
:return: O estágio como `int`.
"""
return self._dados[1]
@estagio.setter
def estagio(self, e: int):
self._dados[1] = e
@property
def limites_inferiores(self) -> List[float]:
"""
Os limites inferiores por patamar para a vazão.
:return: Os limites como `list[float]`.
"""
return self._dados[2::2]
@limites_inferiores.setter
def limites_inferiores(self, lim: List[float]):
novos = len(lim)
atuais = len(self.limites_inferiores)
if novos != atuais:
raise ValueError("Número de limites incompatível. De" +
f"vem ser fornecidos {atuais}, mas foram {novos}")
self._dados[2::2] = lim
@property
def limites_superiores(self) -> List[float]:
"""
Os limites superiores por patamar para a vazão.
:return: Os limites como `list[float]`.
"""
return self._dados[3::2]
@limites_superiores.setter
def limites_superiores(self, lim: List[float]):
novos = len(lim)
atuais = len(self.limites_superiores)
if novos != atuais:
raise ValueError("Número de limites incompatível. De" +
f"vem ser fornecidos {atuais}, mas foram {novos}")
self._dados[3::2] = lim
[documentos]class CQ(RegistroDecomp):
"""
Registro que contém os coeficientes das usinas hidráulicas
nas restrições de vazão.
"""
mnemonico = "CQ"
def __init__(self):
super().__init__(CQ.mnemonico, True)
self._dados = [0, 0, 0, 0.0, ""]
def le(self):
reg_cod = RegistroIn(3)
reg_estagio = RegistroIn(2)
reg_uhe = RegistroIn(3)
reg_fator = RegistroFn(10)
reg_tipo = RegistroAn(4)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_estagio.le_registro(self._linha, 9)
self._dados[2] = reg_uhe.le_registro(self._linha, 14)
self._dados[3] = reg_fator.le_registro(self._linha, 19)
self._dados[4] = reg_tipo.le_registro(self._linha, 34)
def escreve(self, arq: IO):
linha = (f"{CQ.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(2) + " " +
f"{self._dados[2]}".rjust(3) + " " +
f"{round(self._dados[3], 2)}".rjust(10))
linha = linha.ljust(34)
linha += self._dados[4]
linha += "\n"
arq.write(linha)
[documentos]class AR(RegistroDecomp):
"""
Registro que contém as configurações de aversão a risco.
"""
mnemonico = "AR"
def __init__(self):
super().__init__(AR.mnemonico, True)
self._dados: int = 0
def le(self):
reg_linha = RegistroIn(3)
self._dados = reg_linha.le_registro(self._linha, 5)
def escreve(self, arq: IO):
linha = (f"{AR.mnemonico}".ljust(4) + " " +
f"{self.dados}".rjust(3) + "\n")
arq.write(linha)
[documentos]class EV(RegistroDecomp):
"""
Registro que contém as configurações de consideração
da evaporação.
"""
mnemonico = "EV"
def __init__(self):
super().__init__(EV.mnemonico, True)
self._dados = [0, ""]
def le(self):
reg_linha = RegistroIn(1)
reg_tipo = RegistroAn(3)
self._dados[0] = reg_linha.le_registro(self._linha, 4)
self._dados[1] = reg_tipo.le_registro(self._linha, 9)
def escreve(self, arq: IO):
linha = (f"{EV.mnemonico}".ljust(4) +
f"{self._dados[0]}" + " " +
f"{self._dados[1]}".rjust(3) + "\n")
arq.write(linha)
@property
def modelo(self) -> int:
return self._dados[0]
@modelo.setter
def modelo(self, m: int):
self._dados[0] = m
@property
def volume_referencia(self) -> str:
return self._dados[1]
@volume_referencia.setter
def volume_referencia(self, v: str):
self._dados[1] = v
[documentos]class FJ(RegistroDecomp):
"""
Registro que contém as configurações de aversão a risco.
"""
mnemonico = "FJ"
def __init__(self):
super().__init__(FJ.mnemonico, True)
self._dados: str = ""
def le(self):
reg_linha = RegistroAn(12)
self._dados = reg_linha.le_registro(self._linha, 4)
def escreve(self, arq: IO):
linha = (f"{FJ.mnemonico}".ljust(4) +
f"{self.dados}".rjust(12) + "\n")
arq.write(linha)
@property
def arquivo(self) -> str:
return self._dados
@arquivo.setter
def arquivo(self, a: str):
self._dados = a
[documentos]class HE(RegistroDecomp):
"""
Registro que contém o cadastro de uma restrição de volume
mínimo armazenado.
"""
mnemonico = "HE"
def __init__(self):
super().__init__(HE.mnemonico, True)
self._dados = [0, 0, 0.0, 0, 0.0, 0]
def le(self):
reg_cod = RegistroIn(3)
reg_tipo_limite = RegistroIn(1)
reg_limite = RegistroFn(10)
reg_estagio = RegistroIn(2)
reg_penal = RegistroFn(10)
reg_inviab = RegistroIn(1)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_tipo_limite.le_registro(self._linha, 9)
self._dados[2] = reg_limite.le_registro(self._linha, 14)
self._dados[3] = reg_estagio.le_registro(self._linha, 25)
self._dados[4] = reg_penal.le_registro(self._linha, 28)
if self._linha[43].isnumeric():
self._dados[5] = reg_inviab.le_registro(self._linha, 43)
def escreve(self, arq: IO):
linha = (f"{HE.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}" + " " +
f"{round(self._dados[2], 2)}".rjust(10) + " " +
f"{self._dados[3]}".rjust(2) + " " +
f"{round(self._dados[4], 2)}".rjust(10) + " " +
f"{self._dados[5]}")
linha += "\n"
arq.write(linha)
@property
def codigo(self) -> int:
"""
O código de cadastro da restrição HE
:return: O código como `int`.
"""
return self._dados[0]
@property
def tipo_limite(self) -> int:
"""
O tipo de limite especificado na restrição HE,
em valor absoluto ou percentual.
:return: O tipo como `int`.
"""
return self._dados[1]
@tipo_limite.setter
def tipo_limite(self, t: int):
self._dados[1] = t
@property
def limite(self) -> float:
"""
O limite para a energia armazenada associada
ao registro HE.
:return: O limite como `float`.
"""
return self._dados[2]
@limite.setter
def limite(self, lim: float):
self._dados[2] = lim
@property
def estagio(self) -> int:
"""
O estágio para consideração da restrição.
:return: O estágio como `int`.
"""
return self._dados[3]
@estagio.setter
def estagio(self, e: int):
self._dados[3] = e
@property
def penalidade(self) -> float:
"""
O valor da penalidade para a violação da restrição.
:return: O valor como `float`.
"""
return self._dados[4]
@penalidade.setter
def penalidade(self, p: float):
self._dados[4] = p
@property
def tipo_penalidade(self) -> int:
"""
O tipo de penalidade a ser considerada ao violar a
restrição (inviabilidade ou penalização).
:return: O tipo como `int`.
"""
return self._dados[5]
@tipo_penalidade.setter
def tipo_penalidade(self, t: int):
self._dados[5] = t
[documentos]class CM(RegistroDecomp):
"""
Registro que contém os coeficientes de uma restrição RHE.
"""
mnemonico = "CM"
def __init__(self):
super().__init__(CM.mnemonico, True)
self._dados = [0, 0, 0.0]
def le(self):
reg_cod = RegistroIn(3)
reg_ree = RegistroIn(3)
reg_coef = RegistroFn(10)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_ree.le_registro(self._linha, 9)
self._dados[2] = reg_coef.le_registro(self._linha, 14)
def escreve(self, arq: IO):
linha = (f"{CM.mnemonico}".ljust(4) +
f"{self._dados[0]}".rjust(3) + " " +
f"{self._dados[1]}".rjust(3) + " " +
f"{formata_numero(self._dados[2], 2, 10)}")
linha += "\n"
arq.write(linha)
@property
def codigo(self) -> int:
return self._dados[0]
@property
def estagio(self) -> int:
return self._dados[1]
@estagio.setter
def estagio(self, e: int):
self._dados[1] = e
@property
def coeficiente(self) -> int:
return self._dados[2]
@coeficiente.setter
def coeficiente(self, c: float):
self._dados[2] = c
class LeituraDadger(LeituraRegistros):
"""
Classe com utilidades gerais para leitura de arquivos
do DECOMP com comentários.
"""
def __init__(self,
diretorio: str):
super().__init__(diretorio)
def _cria_registros_leitura(self) -> List[RegistroDecomp]:
"""
Método que cria a lista de registros a serem lidos no arquivo.
Implementa o Factory Pattern.
"""
MAX_UHE = 200
MAX_UTE = 200
MAX_UE = 10
MAX_RE = 200
MAX_ESTAGIOS = 7
MAX_SUBSIS = 5
MAX_AC_UHE = 10
MAX_REE = 12
MAX_RELATORIOS = 10
te: List[RegistroDecomp] = [TE()]
rt: List[RegistroDecomp] = [RT(), RT()]
sb: List[RegistroDecomp] = [SB() for _ in range(MAX_SUBSIS)]
uh: List[RegistroDecomp] = [UH() for _ in range(MAX_UHE)]
ct: List[RegistroDecomp] = [CT() for _ in range(MAX_UTE)]
ue: List[RegistroDecomp] = [UE() for _ in range(MAX_UE)]
dp: List[RegistroDecomp] = [DP() for _ in
range(MAX_SUBSIS * MAX_ESTAGIOS)]
cd: List[RegistroDecomp] = [CD() for _ in
range(MAX_SUBSIS * MAX_ESTAGIOS)]
pq: List[RegistroDecomp] = [PQ() for _ in
range(MAX_SUBSIS * MAX_ESTAGIOS)]
ri: List[RegistroDecomp] = [RI() for _ in range(MAX_ESTAGIOS)]
ia: List[RegistroDecomp] = [IA() for _ in
range(MAX_SUBSIS * MAX_SUBSIS)]
tx: List[RegistroDecomp] = [TX()]
gp: List[RegistroDecomp] = [GP()]
ni: List[RegistroDecomp] = [NI()]
dt: List[RegistroDecomp] = [DT()]
mp: List[RegistroDecomp] = [MP() for _ in range(MAX_UHE)]
mt: List[RegistroDecomp] = [MT() for _ in range(MAX_UTE)]
fd: List[RegistroDecomp] = [FD() for _ in range(MAX_UHE)]
ve: List[RegistroDecomp] = [VE() for _ in range(MAX_UHE)]
re: List[RegistroDecomp] = [RE() for _ in range(MAX_RE)]
lu: List[RegistroDecomp] = [LU() for _ in
range(MAX_RE * MAX_ESTAGIOS)]
fu: List[RegistroDecomp] = [FU() for _ in range(MAX_RE)]
ft: List[RegistroDecomp] = [FT() for _ in range(MAX_RE)]
vi: List[RegistroDecomp] = [VI(), VI()]
ac: List[RegistroDecomp] = [AC() for _ in
range(MAX_UHE * MAX_AC_UHE)]
ir: List[RegistroDecomp] = [IR() for _ in range(MAX_RELATORIOS)]
fc: List[RegistroDecomp] = [FC(), FC()]
ti: List[RegistroDecomp] = [TI() for _ in range(MAX_UHE)]
rq: List[RegistroDecomp] = [RQ() for _ in range(MAX_REE)]
ez: List[RegistroDecomp] = [EZ() for _ in range(MAX_UHE)]
hv: List[RegistroDecomp] = [HV() for _ in range(MAX_UHE)]
lv: List[RegistroDecomp] = [LV() for _ in
range(MAX_UHE * MAX_ESTAGIOS)]
cv: List[RegistroDecomp] = [CV() for _ in range(MAX_UHE)]
hq: List[RegistroDecomp] = [HQ() for _ in range(MAX_UHE)]
lq: List[RegistroDecomp] = [LQ() for _ in
range(MAX_UHE * MAX_ESTAGIOS)]
cq: List[RegistroDecomp] = [CQ() for _ in
range(MAX_UHE * MAX_ESTAGIOS)]
ar: List[RegistroDecomp] = [AR()]
ev: List[RegistroDecomp] = [EV()]
fj: List[RegistroDecomp] = [FJ()]
he: List[RegistroDecomp] = [HE() for _ in
range(MAX_REE * MAX_ESTAGIOS)]
cm: List[RegistroDecomp] = [CM() for _ in
range(MAX_REE * MAX_ESTAGIOS)]
fp: List[RegistroDecomp] = [FP() for _ in range(MAX_UHE)]
return (te + rt + sb + uh + ct + ue + dp + cd + pq +
ri + ia + tx + gp + ni + dt + mp + mt +
fd + ve + re + lu + fu + ft + vi + ac +
ir + fc + ti + rq + ez + hv + lv + cv +
hq + lq + cq + ar + ev + fj + he + cm + fp)