def le(self):
reg_codigo = RegistroIn(3)
reg_subsis = RegistroIn(2)
reg_lag = RegistroIn(1)
self._dados[0] = reg_codigo.le_registro(self._linha, 4)
self._dados[1] = reg_subsis.le_registro(self._linha, 9)
self._dados[2] = reg_lag.le_registro(self._linha, 14)
def le(self, arq: IO):
def converte_tabela_em_df() -> pd.DataFrame:
cols = [
"GT Min Pat. 1", "GT Max Pat. 1", "Custo Pat. 1",
"GT Min Pat. 2", "GT Max Pat. 2", "Custo Pat. 2",
"GT Min Pat. 3", "GT Max Pat. 3", "Custo Pat. 3"
]
df = pd.DataFrame(tabela, columns=cols)
df["Código"] = numeros
df["Usina"] = usinas
df["Subsistema"] = subsistemas
df["Estágio"] = estagios
df = df[["Código", "Usina", "Subsistema", "Estágio"] + cols]
return df
# Salta as linhas de cabeçalho
for _ in range(4):
arq.readline()
reg_num = RegistroIn(3)
reg_usina = RegistroAn(10)
reg_subsis = RegistroAn(6)
reg_estagio = RegistroIn(7)
reg_valores = RegistroFn(7)
numeros: List[int] = []
usinas: List[str] = []
subsistemas: List[str] = []
estagios: List[int] = []
tabela = np.zeros((5000, 9))
i = 0
num_atual = 0
usina_atual = ""
subsis_atual = ""
while True:
# Confere se a leitura não acabou
linha = arq.readline()
if "X---X----------X" in linha:
tabela = tabela[:i, :]
self._dados = converte_tabela_em_df()
break
# Senão, lê mais uma linha
# Verifica se começa uma nova UTE na linha
if len(linha[4:7].strip()) > 0:
num_atual = reg_num.le_registro(linha, 4)
usina_atual = reg_usina.le_registro(linha, 8)
subsis_atual = reg_subsis.le_registro(linha, 19)
# Lê as propriedades existentes em todas as linhas
numeros.append(num_atual)
usinas.append(usina_atual)
subsistemas.append(subsis_atual)
estagios.append(reg_estagio.le_registro(linha, 26))
tabela[i, :] = reg_valores.le_linha_tabela(linha, 34, 1, 9)
i += 1
def le(self, arq: IO):
def converte_tabela_em_df() -> pd.DataFrame:
colunas = [
"GT Min Pat 1", "GT Max Pat 1", "Custo GT Pat 1",
"GT Min Pat 2", "GT Max Pat 2", "Custo GT Pat 2",
"GT Min Pat 3", "GT Max Pat 3", "Custo GT Pat 3"
]
df = pd.DataFrame(tabela, columns=colunas)
df["Código"] = numeros
df["Usina"] = usinas
df["Subsistema"] = subsistemas
df["Estágio"] = estagios
df = df[["Código", "Usina", "Subsistema", "Estágio"] + colunas]
return df
# Pula 4 linhas
for _ in range(4):
arq.readline()
# Variáveis auxiliares
reg_num = RegistroIn(3)
reg_nome = RegistroAn(10)
reg_subsis = RegistroAn(6)
reg_estagio = RegistroIn(7)
reg_valores = RegistroFn(7)
numeros: List[int] = []
usinas: List[str] = []
subsistemas: List[str] = []
estagios: List[int] = []
tabela = np.zeros((2000, 9))
numero_atual = 0
usina_atual = ""
subsistema_atual = ""
i = 0
while True:
linha: str = arq.readline()
if BlocoDadosUsinasRelGNL.str_fim in linha:
tabela = tabela[:i, :]
self._dados = converte_tabela_em_df()
break
if linha[4:7].strip().isnumeric():
numero_atual = reg_num.le_registro(linha, 4)
if len(linha[8:18].strip()) > 0:
usina_atual = reg_nome.le_registro(linha, 8)
if len(linha[19:26].strip()) > 0:
subsistema_atual = reg_subsis.le_registro(linha, 19)
numeros.append(numero_atual)
usinas.append(usina_atual)
subsistemas.append(subsistema_atual)
estagios.append(reg_estagio.le_registro(linha, 26))
tabela[i, :] = reg_valores.le_linha_tabela(linha, 34, 1, 9)
i += 1
def le_tabela(linha: str) -> np.ndarray:
indice_ree = int(linha.split("REE: ")[1].split("-")[0].strip())
ree = linha.split("REE: ")[1].split("/")[0].split("-")[1].strip()
subsis = linha.split("SUBSISTEMA: ")[1].split("-")[1].strip()
# Salta uma linha para identificar o número de estágios
arq.readline()
lin = arq.readline()
sems = [
s for s in lin.split(" ")
if (len(s) > 0 and ("Sem" in s or "Mes" in s))
]
n_semanas = len(sems)
arq.readline()
# Começa a ler os cenários
reg_cen = RegistroIn(3)
reg_ena = RegistroFn(8)
tab = np.zeros((1000, n_semanas + 1))
i = 0
while True:
lin = arq.readline()
if len(lin) < 4:
tab = tab[:i, :]
break
tab[i, 0] = reg_cen.le_registro(lin, 4)
tab[i, 1:] = reg_ena.le_linha_tabela(lin, 8, 1, n_semanas)
indices_rees.append(indice_ree)
rees.append(ree)
subsistemas.append(subsis)
i += 1
return tab
def le(self, arq: IO):
def converte_tabela_em_df() -> pd.DataFrame:
df = pd.DataFrame()
df["Iteração"] = iteracoes
df["FWD/BWD"] = fwds_bwds
df["Estágio"] = estagios
df["Cenário"] = cenarios
df["Restrição"] = restricoes
df["Violação"] = violacoes
df["Unidade"] = unidades
return df
# Salta uma linha
arq.readline()
reg_iter = RegistroIn(9)
reg_fwdbwd = RegistroIn(14)
reg_estagio = RegistroIn(8)
reg_cenario = RegistroIn(8)
reg_restricao = RegistroAn(51)
reg_violacao = RegistroAn(22)
iteracoes: List[int] = []
fwds_bwds: List[int] = []
estagios: List[int] = []
cenarios: List[int] = []
restricoes: List[str] = []
violacoes: List[float] = []
unidades: List[str] = []
while True:
# Confere se a leitura não acabou
linha = arq.readline()
if len(linha.strip()) < 5:
self._dados = converte_tabela_em_df()
break
# Senão, lê mais uma linha
iteracoes.append(reg_iter.le_registro(linha, 4))
fwds_bwds.append(reg_fwdbwd.le_registro(linha, 14))
estagios.append(reg_estagio.le_registro(linha, 29))
cenarios.append(reg_cenario.le_registro(linha, 38))
restricoes.append(reg_restricao.le_registro(linha, 47))
viol = reg_violacao.le_registro(linha, 99)
violacao = float(viol.strip().split(" ")[0])
unidade = viol.strip().split(" ")[1]
violacoes.append(violacao)
unidades.append(unidade)
def le(self, arq: IO):
def converte_tabela_em_df() -> pd.DataFrame:
colunas = ["Pat 1", "Pat 2", "Pat 3"]
df = pd.DataFrame(tabela, columns=colunas)
df["Código"] = numeros
df["Usina"] = usinas
df["Lag"] = lags
df["Subsistema"] = subsistemas
df["Período"] = periodos
df = df[["Código", "Usina", "Lag", "Subsistema", "Período"] +
colunas]
return df
# Pula 4 linhas
for _ in range(4):
arq.readline()
# Variáveis auxiliares
reg_num = RegistroIn(3)
reg_nome = RegistroAn(10)
reg_subsis = RegistroAn(6)
reg_lag = RegistroIn(3)
reg_periodo = RegistroIn(9)
reg_valores = RegistroFn(10)
numeros: List[int] = []
usinas: List[str] = []
subsistemas: List[str] = []
periodos: List[int] = []
lags: List[int] = []
tabela = np.zeros((2000, 3))
i = 0
while True:
linha: str = arq.readline()
if len(linha) < 3:
tabela = tabela[:i, :]
self._dados = converte_tabela_em_df()
break
numeros.append(reg_num.le_registro(linha, 3))
usinas.append(reg_nome.le_registro(linha, 8))
lags.append(reg_lag.le_registro(linha, 20))
subsistemas.append(reg_subsis.le_registro(linha, 24))
periodos.append(reg_periodo.le_registro(linha, 31))
tabela[i, :] = reg_valores.le_linha_tabela(linha, 41, 1, 3)
i += 1
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)
for j in range(3):
self._dados[4 + 3 * j] = reg_inflex.le_registro(self._linha,
29 + 20 * j)
self._dados[5 + 3 * j] = reg_disp.le_registro(self._linha,
34 + 20 * j)
self._dados[6 + 3 * j] = reg_cvu.le_registro(self._linha,
39 + 20 * j)
def le(self):
reg_cod = RegistroIn(3)
reg_subsistema = RegistroIn(2)
reg_estagio = RegistroIn(2)
reg_geracao = RegistroFn(10)
reg_duracao = RegistroFn(5)
reg_data = RegistroAn(8)
self._dados[0] = reg_cod.le_registro(self._linha, 4)
self._dados[1] = reg_subsistema.le_registro(self._linha, 9)
self._dados[2] = reg_estagio.le_registro(self._linha, 14)
self._dados[3] = reg_geracao.le_registro(self._linha, 19)
if len(self._linha[29:34].strip()) > 0:
self._dados[4] = reg_duracao.le_registro(self._linha, 29)
self._dados[5] = reg_geracao.le_registro(self._linha, 34)
if len(self._linha[44:49].strip()) > 0:
self._dados[6] = reg_duracao.le_registro(self._linha, 44)
self._dados[7] = reg_geracao.le_registro(self._linha, 49)
if len(self._linha[59:64].strip()) > 0:
self._dados[8] = reg_duracao.le_registro(self._linha, 59)
self._dados[9] = reg_data.le_registro(self._linha, 65)
def le(self, arq: IO):
def converte_tabela_em_df() -> pd.DataFrame:
df = pd.DataFrame(tabela)
cols = ["Inicial"
] + [f"Estágio {s}" for s in range(1, n_semanas + 1)]
df.columns = cols
df["Subsistema"] = subsistemas
df["REE"] = rees
df = df[["Subsistema", "REE"] + cols]
return df
# Salta uma linha
arq.readline()
# Descobre o número de semanas
linha = arq.readline()
sems = [
s for s in linha.split(" ")
if (len(s) > 0 and ("Sem" in s or "Mes" in s))
]
reg_ree = RegistroAn(12)
reg_ssis = RegistroIn(4)
n_semanas = len(sems)
rees: List[str] = []
subsistemas: List[int] = []
tabela = np.zeros((MAX_REES, n_semanas + 1))
# Salta outra linha
arq.readline()
i = 0
while True:
# Confere se a leitura não acabou
linha = arq.readline()
if "X------X" in linha:
tabela = tabela[:i, :]
self._dados = converte_tabela_em_df()
break
# Senão, lê mais uma linha
# Subsistema e REE
ree = reg_ree.le_registro(linha, 4)
ssis = reg_ssis.le_registro(linha, 22) - 1
rees.append(ree)
subsistemas.append(ssis)
# Semanas
ci = 28
for col in range(n_semanas + 1):
cf = ci + 6
conteudo = linha[ci:cf].strip()
if not conteudo.replace(".", "0").isnumeric():
tabela[i, col] = np.nan
else:
tabela[i, col] = float(conteudo)
ci = cf + 1
i += 1
def le(self, arq: IO):
def converte_tabela_em_df() -> pd.DataFrame:
df = pd.DataFrame(tabela)
cols = ["Inicial"
] + [f"Estágio {s}" for s in range(1, n_semanas + 1)]
df.columns = cols
df["Usina"] = usinas
df["Número"] = numeros
df = df[["Número", "Usina"] + cols]
return df
# Salta duas linhas
arq.readline()
arq.readline()
# Descobre o número de semanas
linha = arq.readline()
sems = [
s for s in linha.split(" ")
if (len(s) > 0 and ("Sem" in s or "Mes" in s))
]
reg_usina = RegistroAn(12)
reg_numero = RegistroIn(4)
reg_vol = RegistroFn(6)
n_semanas = len(sems)
usinas: List[str] = []
numeros: List[int] = []
tabela = np.zeros((300, n_semanas + 1))
# Salta outra linha
arq.readline()
i = 0
while True:
# Confere se a leitura não acabou
linha = arq.readline()
if "X-------X" in linha:
tabela = tabela[:i, :]
self._dados = converte_tabela_em_df()
break
# Senão, lê mais uma linha
# Subsistema e REE
numero = reg_numero.le_registro(linha, 4)
usina = reg_usina.le_registro(linha, 9)
numeros.append(numero)
usinas.append(usina)
# Semanas
tabela[i, :] = reg_vol.le_linha_tabela(linha, 23, 1, n_semanas + 1)
i += 1
def le(self, arq: IO):
def converte_tabela_em_df() -> pd.DataFrame:
cols = [
"Patamar 1", "Mercado 1", "Patamar 2", "Mercado 2",
"Patamar 3", "Mercado 3"
]
df = pd.DataFrame(tabela, columns=cols)
df["Estágio"] = estagios
df["Subsistema"] = subsistemas
df = df[["Estágio", "Subsistema"] + cols]
return df
# Salta as linhas de cabeçalho
for _ in range(4):
arq.readline()
reg_estagio = RegistroIn(9)
reg_subsis = RegistroAn(6)
reg_valores = RegistroFn(9)
estagios: List[int] = []
subsistemas: List[str] = []
tabela = np.zeros((100, 6))
i = 0
estagio_atual = 0
while True:
# Confere se a leitura não acabou
linha = arq.readline()
if "X---------X------X" in linha:
tabela = tabela[:i, :]
self._dados = converte_tabela_em_df()
break
# Senão, lê mais uma linha
# Verifica se começa um novo estágio na linha
if len(linha[4:13].strip()) > 0:
estagio_atual = reg_estagio.le_registro(linha, 4)
# Lê as propriedades existentes em todas as linhas
estagios.append(estagio_atual)
subsistemas.append(reg_subsis.le_registro(linha, 14))
tabela[i, :] = reg_valores.le_linha_tabela(linha, 21, 1, 6)
i += 1
def le(self, arq: IO):
def converte_tabela_em_df() -> pd.DataFrame:
cols = [f"Estágio {i}" for i in range(1, n_semanas + 1)]
df = pd.DataFrame(tabela, columns=cols)
df["Código"] = numeros
df["Usina"] = usinas
df = df[["Código", "Usina"] + cols]
return df
# Salta uma linha
arq.readline()
# Descobre o número de estágios
linha = arq.readline()
sems = [
s for s in linha.split(" ")
if (len(s) > 0 and ("Sem" in s or "Mes" in s))
]
n_semanas = len(sems)
reg_num = RegistroIn(3)
reg_usina = RegistroAn(12)
reg_valores = RegistroFn(6)
numeros: List[int] = []
usinas: List[str] = []
tabela = np.zeros((300, n_semanas))
# Salta outra linha
arq.readline()
i = 0
while True:
# Confere se a leitura não acabou
linha = arq.readline()
if "X---X------------X" in linha:
tabela = tabela[:i, :]
self._dados = converte_tabela_em_df()
break
# Senão, lê mais uma linha
numeros.append(reg_num.le_registro(linha, 4))
usinas.append(reg_usina.le_registro(linha, 8))
tabela[i, :] = reg_valores.le_linha_tabela(linha, 21, 1, n_semanas)
i += 1
def le(self):
reg_mes = RegistroIn(2)
reg_semanas = RegistroIn(1)
self._dados[0] = reg_mes.le_registro(self._linha, 4)
self._dados[1] = reg_semanas.le_registro(self._linha, 9)
def le(self, arq: IO):
def converte_tabela_para_df() -> pd.DataFrame:
df = pd.DataFrame(tabela)
cols = [
"Despacho Pat. 1", "Duração Pat. 1", "Despacho Pat. 2",
"Duração Pat. 2", "Despacho Pat. 3", "Duração Pat. 3", "Custo"
]
df.columns = cols
df["Subsistema"] = subsistemas
df["Usina"] = usinas
df["Lag"] = lags
df["Estágio"] = semanas
df["Início Semana"] = inicio_semanas
df = df[["Subsistema", "Usina", "Lag", "Estágio", "Início Semana"]
+ cols]
return df
# Variáveis auxiliares
str_tabela = "Sinalizacao de Despacho antecipado em k meses"
reg_subsis = RegistroAn(3)
reg_usina = RegistroAn(11)
reg_lag = RegistroIn(7)
reg_semana = RegistroAn(7)
reg_despacho = RegistroFn(8)
reg_duracao = RegistroFn(7)
reg_custo = RegistroFn(10)
reg_inicio = RegistroAn(12)
subsistemas = []
usinas = []
lags = []
semanas = []
inicio_semanas = []
# Salta uma linha e extrai a semana
tabela = np.zeros((MAX_ESTAGIOS * 10, 7))
i = 0
achou_tabela = False
while True:
linha = arq.readline()
# Verifica se acabou
if BlocoRelatorioOperacaoRelGNL.str_fim in linha:
tabela = tabela[:i, :]
self._dados = converte_tabela_para_df()
break
# Senão, procura a linha que identifica o subsistema
if str_tabela in linha:
achou_tabela = True
# Salta 4 linhas
for _ in range(4):
arq.readline()
elif len(linha) < 5:
achou_tabela = False
# Se está lendo um subsistema e achou a linha de valores médios
elif achou_tabela:
subsistemas.append(reg_subsis.le_registro(linha, 4))
usinas.append(reg_usina.le_registro(linha, 8))
lags.append(reg_lag.le_registro(linha, 20))
semanas.append(reg_semana.le_registro(linha, 28))
inicio_semanas.append(reg_inicio.le_registro(linha, 98))
tabela[i, 0] = reg_despacho.le_registro(linha, 36)
tabela[i, 1] = reg_duracao.le_registro(linha, 44)
tabela[i, 2] = reg_despacho.le_registro(linha, 53)
tabela[i, 3] = reg_duracao.le_registro(linha, 61)
tabela[i, 4] = reg_despacho.le_registro(linha, 70)
tabela[i, 5] = reg_duracao.le_registro(linha, 78)
tabela[i, 6] = reg_custo.le_registro(linha, 87)
i += 1
def le(self, arq: IO):
def converte_tabela_em_df() -> pd.DataFrame:
colunas = [
"Iteração", "Zinf", "Zsup", "Gap (%)", "Tempo (s)",
"Tot. Def. Demanda (MWmed)", "Tot. Def. Niv. Seg. (MWmes)",
"Num. Inviab", "Tot. Inviab (MWmed)", "Tot. Inviab (m3/s)",
"Tot. Inviab (Hm3)"
]
tipos = {
"Iteração": np.int64,
"Zinf": np.float64,
"Zsup": np.float64,
"Gap (%)": np.float64,
"Tempo (s)": np.int64,
"Tot. Def. Demanda (MWmed)": np.float64,
"Tot. Def. Niv. Seg. (MWmes)": np.float64,
"Num. Inviab": np.int64,
"Tot. Inviab (MWmed)": np.float64,
"Tot. Inviab (m3/s)": np.float64,
"Tot. Inviab (Hm3)": np.float64
}
df = pd.DataFrame(tabela, columns=colunas)
df = df.astype(tipos)
return df
# Salta 9 linhas linha
for _ in range(9):
arq.readline()
reg_iter = RegistroIn(4)
reg_z = RegistroFn(12)
reg_gap = RegistroFn(16)
reg_tempo = RegistroAn(8)
reg_def_demanda = RegistroFn(10)
reg_def_niv_seg = RegistroFn(12)
reg_num_inviab = RegistroIn(7)
reg_tot_inviab = RegistroFn(12)
tabela = np.zeros((999, 11))
i = 0
while True:
# Confere se a leitura não acabou
linha = arq.readline()
if len(linha) < 5:
tabela = tabela[:i, :]
self._dados = converte_tabela_em_df()
break
if "----" in linha:
continue
# Senão, lê mais uma linha
tabela[i, 0] = reg_iter.le_registro(linha, 4)
if "*" in linha[9:21]:
tabela[i, 1] = np.nan
else:
tabela[i, 1] = reg_z.le_registro(linha, 9)
if "*" in linha[22:34]:
tabela[i, 2] = np.nan
else:
tabela[i, 2] = reg_z.le_registro(linha, 22)
tabela[i, 3] = reg_gap.le_registro(linha, 35)
tempo = reg_tempo.le_registro(linha, 52)
parcelas = tempo.split(":")
segundos = (int(parcelas[0]) * 3600 + int(parcelas[1]) * 60 +
int(parcelas[2]))
tabela[i, 4] = segundos
tabela[i, 5] = reg_def_demanda.le_registro(linha, 61)
if str(linha[72:85]).isnumeric():
tabela[i, 6] = reg_def_niv_seg.le_registro(linha, 72)
else:
tabela[i, 6] = np.nan
tabela[i, 7] = reg_num_inviab.le_registro(linha, 85)
tabela[i, 8] = reg_tot_inviab.le_registro(linha, 93)
tabela[i, 9] = reg_tot_inviab.le_registro(linha, 106)
tabela[i, 10] = reg_tot_inviab.le_registro(linha, 119)
i += 1
def le(self, arq: IO):
def converte_tabela_para_df() -> pd.DataFrame:
cols = [
"Volume Ini (% V.U)", "Volume Fin (% V.U)",
"Volume Esp. (% V.U)", "Qnat (m3/s)", "Qnat (% MLT)",
"Qafl (m3/s)", "Qdef (m3/s)", "Geração Pat 1", "Geração Pat 2",
"Geração Pat 3", "Geração Média", "Vertimento Turbinável",
"Vertimento Não-Turbinável", "Ponta", "FPCGC"
]
df = pd.DataFrame(tabela, columns=cols)
cols_adic = [
"Código", "Usina", "Evaporação", "Tempo de Viagem",
"Cota Abaixo da Crista do Vert", "Def. Mínima = 0"
]
df["Código"] = numeros
df["Usina"] = usinas
df["Evaporação"] = evaporacao
df["Tempo de Viagem"] = tv_afluencia
df["Cota Abaixo da Crista do Vert"] = cota_abaixo_crista
df["Def. Mínima = 0"] = def_minima_zero
df = df[cols_adic + cols]
return df
def le_se_tem_valor(digitos: int, linha: str, coluna_inicio: int):
coluna_fim = coluna_inicio + digitos
trecho = linha[coluna_inicio:coluna_fim].strip()
valor = None
if len(trecho) > 0 and "---" not in trecho:
reg = RegistroFn(digitos)
valor = reg.le_registro(linha, coluna_inicio)
else:
valor = np.nan
return valor
# Salta duas linhas
arq.readline()
arq.readline()
# Variáveis auxiliares
reg_numero = RegistroIn(4)
reg_usina = RegistroAn(12)
reg_flags = RegistroAn(4)
reg_volume = RegistroFn(5)
reg_tabela = RegistroFn(7)
numeros: List[int] = []
usinas: List[str] = []
evaporacao: List[bool] = []
tv_afluencia: List[bool] = []
cota_abaixo_crista: List[bool] = []
def_minima_zero: List[bool] = []
# Salta uma linha e extrai a semana
tabela = np.zeros((300, 15))
i = 0
while True:
linha: str = arq.readline()
# Verifica se acabou
if BlocoRelatorioOperacaoUHERelato.str_fim in linha:
tabela = tabela[:i, :]
self._dados = converte_tabela_para_df()
break
numeros.append(reg_numero.le_registro(linha, 4))
usinas.append(reg_usina.le_registro(linha, 9))
flags = reg_flags.le_registro(linha, 22)
evaporacao.append("#" in flags)
tv_afluencia.append("*" in flags)
cota_abaixo_crista.append("@" in flags)
def_minima_zero.append("$" in flags)
tem_volume = len(linha[27:33].strip()) > 0
if tem_volume:
tabela[i, :3] = reg_volume.le_linha_tabela(linha, 27, 1, 3)
else:
tabela[i, :3] = np.nan
tabela[i, 3] = le_se_tem_valor(7, linha, 45)
tabela[i, 4] = le_se_tem_valor(6, linha, 54)
tabela[i, 5] = le_se_tem_valor(7, linha, 63)
tabela[i, 6:11] = reg_tabela.le_linha_tabela(linha, 72, 5, 1)
tabela[i, 11] = le_se_tem_valor(7, linha, 112)
tabela[i, 12] = le_se_tem_valor(7, linha, 120)
tabela[i, 13] = le_se_tem_valor(7, linha, 128)
tabela[i, 14] = le_se_tem_valor(7, linha, 136)
i += 1
def le(self, arq: IO):
reg_dias = RegistroIn(1)
self._dados[0] = reg_dias.le_registro(arq.readline(), 54)
self._dados[1] = reg_dias.le_registro(arq.readline(), 54)