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

-
#importação das bibliotecas básicas
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import math
#----------------------------------------------------------------------------------
-
#arquivos
#Amostra de Alumínio:
#df1=pd.read_table('Al60mm.txt', sep="\t", header=None,
names=["tempo","amplitude","x"])
df1=pd.read_table('Aluminium_60mm_Conf_21.5_MPa_S1WZ.txt', sep="\t", header=None,
names=["tempo","amplitude","x"])
#df1=pd.read_table('S1_face_to_face_4A1_SE_SAT.txt', sep="\t", header=None,
names=["tempo","amplitude","x"])
df1 = df1.iloc[20:].astype('float')
x11=df1['tempo'][20:1500]
y11=df1['amplitude'][20:1500]
med_y11=sum(y11)/len(x11)
y11=y11-med_y11
#Amostra Experimental:
#df2=pd.read_table('4A4-SE.txt',sep="\t", header=None,
names=["tempo","amplitude","x"])
df2=pd.read_table('4.A1_SE_SAT_confi_24.5_MPa_L58.5mm_D38mm_S1WZ.txt', sep="\t",
header=None, names=["tempo","amplitude","x"])
#df2=pd.read_table('4.A1_SE_UNLOAD_confi_5.5_MPa_L58.5mm_D38mm_PWZ.txt', sep="\t",
header=None, names=["tempo","amplitude","x"])
#df2=pd.read_table('4.A1_SE_SAT_axi_6.0_confi_5.5_MPa_L58.5mm_D38mm_PWZ.txt',
sep="\t", header=None, names=["tempo","amplitude","x"])
#df2=pd.read_table('4.A1_SE_SAT_axi_25.0_confi_24.5_MPa_L58.5mm_D38mm_PWZ.txt',
sep="\t", header=None, names=["tempo","amplitude","x"])
#df2=pd.read_table('4A1SE_SAT_25MPa_PWZ_Prep.txt', sep="\t", header=None,
names=["tempo","amplitude"])
#df2=pd.read_table('4A4SE_PWZ_Prep2.txt',sep="\t", header=None,
names=["tempo","amplitude"])
#df2=pd.read_csv('4A4SE_PWZ_Prep.csv')
#df2=pd.read_csv('9CAL_PMT_SAT_axi_8.0_confi_7.5_MPa_L46.8_D37.83mm_PWZ.txt_prep.cs
v')
#x21=df2['tempo'][:]-7.68
#x21=x21[50:1000]
df2 = df2.iloc[20:].astype('float')
x21=df2['tempo'][20:1500]
y21=df2['amplitude'][20:1500]
med_y21=sum(y21)/len(x21)
y21=y21-med_y21
#figuras
"""
plt.figure(figsize=(10,5),layout="constrained")
plt.subplot(1,1,1)
plt.title('Gráfico da amostra padrão de Alumínio')
plt.xlabel("tempo (µs)")
plt.ylabel("amplitude (mV)")
plt.grid(True)
plt.plot(x11[0:2000],y11[0:2000],color='black')
plt.show()
"""
"""
plt.figure(figsize=(10,5),layout="constrained")
plt.subplot(1,1,1)
plt.title('Gráfico da amostra de estudo')
plt.xlabel("tempo (µs)")
plt.ylabel("amplitude (mV)")
plt.grid(True)
plt.plot(x21[0:2000],y21[0:2000],color='blue')
plt.show()
"""

#--------------------------------------------------------------------------------
"""
x_12=df1['tempo'][280:300]
y_12=df1['amplitude'][280:300]
x_22=df2['tempo'][330:360]
y_22=df2['amplitude'][330:360]
plt.figure(figsize=(10,10),layout="constrained")
plt.subplot(2,1,1)
plt.title('Gráfico da amostra padrão de Alumínio')
plt.xlabel("tempo em micro segundos")
for a,b in zip(x_12, y_12):
plt.text(a-.1, b, str(round(a,3)),rotation=-30.)
plt.plot(x_12,y_12,color='grey')
plt.scatter(x_12,y_12,color='grey')
plt.subplot(2,1,2)
plt.title('Gráfico da amostra experimental')
plt.xlabel("tempo em micro segundos")
for a,b in zip(x_22, y_22):
plt.text(a-.1, b, str(round(a,3)),rotation=-45.)
plt.plot(x_22,y_22)
plt.scatter(x_22,y_22)
plt.show()
"""
#----------------------------------------------------------------------------------

#----------------------------------------------------------------------------------
-
"""DETERMINAÇÃO DO TEMPO DE 1A QUEBRA (ESTIMATIVA VISUAL) ENTRADA DE VALORES:
TEMPO DA 1A QUEBRA: AMOSTRA DE ALUMÍNIO.
TEMPO DA 1A QUEBRA: AMOSTRA EXPERIMENTAL"""

#t_amo_alu=float(input('ENTRE COM O VALOR DO TEMPO (µs) DE 1A QUEBRA PARA A AMOSTRA

DE REFERÊNCIA'))
t_amo_exp=float(input('ENTRE COM O VALOR DO TEMPO (µs) DE QUEBRA PARA A AMOSTRA
EXPERIMENTAL'))

#t_amo_alu=float(17.0)
#t_amo_exp=float(20.0)

t_amo_alu=float(31.92)
#t_amo_exp=float(19.86)

#INSERÇÃO DE PARÂMETROS: COMPRIMENTOS DAS AMOSTRAS

#L_amo_alu=float(input('ENTRE COM O VALOR DO COMPRIMENTO (cm) PARA A AMOSTRA DE
REFERÊNCIA'))
#L_amo_exp=float(input('ENTRE COM O VALOR DO COMPRIMENTO (cm) PARA A AMOSTRA
EXPERIMENTAL'))
L_amo_alu=float(6.0)
L_amo_exp=float(5.8500000000000000)

#INSERÇÃO DE PARÂMETROS: ENTRE COM O VALOR DO INCREMENTO DE TEMPO dt e ENTRE COM O

VALOR DO TEMPO FACE-TO-FACE
#dt=float(input('ENTRE COM O VALOR DO INCREMENTO (dt) DE TEMPO (µs)'))
#t_face=float(input('ENTRE COM O VALOR FACE-TO-FACE (µs)'))

dt=float(0.1)
t_face=float(12.7500000)

#----------------------------------------------------------------------------------
-
#CÁLCULO DA VELOCIDADE DE PROPAGAÇÃO DA ONDA P NAS AMOSTRAS
t_1a_que_alu=t_amo_alu
t_1a_que_amo=t_amo_exp
vel_amo_alu=round( ( L_amo_alu/(t_amo_alu-t_face)*10000),1 )
vel_amo_exp=round( ( L_amo_exp/(t_amo_exp-t_face)*10000),1 )
print(vel_amo_alu,vel_amo_exp)
#----------------------------------------------------------------------------------
----------------
#TAPER da função
freq1=list(x11)
N=3*t_1a_que_alu
L=2*t_1a_que_alu
LT=N/6
lista1=[]
x1=[]
for i1 in freq1:
if(i1<LT):
w1= 0
lista1.append(w1)
x1.append(i1)
if(LT<=i1<=t_1a_que_alu):
w1 = 0.5*( 1+np.cos( (4*(np.pi)*i1)/(L) ) )
lista1.append(w1)
x1.append(i1)
if(t_1a_que_alu<i1<=N):
w1=1
lista1.append(w1)
x1.append(i1)
if(N<i1<=(N+LT)):
w1= 0.5*( 1+np.cos( (4*(np.pi)*i1)/(L) ) )
lista1.append(w1)
x1.append(i1)
if((N+LT)<i1):
w1= 0
lista1.append(w1)
x1.append(i1)
dados1=np.multiply(lista1,y11)
freq2=list(x21)
N=3*t_1a_que_amo
L=2*t_1a_que_amo
LT=N/6
lista2=[]
x2=[]
for i2 in freq2:
if(i2<LT):
 w2= 0
lista2.append(w2)
x2.append(i2)
if(LT<=i2<=t_1a_que_amo):
w2 = 0.5*( 1+np.cos( (4*(np.pi)*i2)/(L) ) )
lista2.append(w2)
x2.append(i2)
if(t_1a_que_amo<i2<N):
w2=1
lista2.append(w2)
x2.append(i2)
if(N<=i2<(N+LT)):
w2= 0.5*( 1+np.cos( (4*(np.pi)*i2)/(L) ) )
lista2.append(w2)
x2.append(i2)
if((N+LT)<=i2):
w2=0
lista2.append(w2)
x2.append(i2)
dados2=np.multiply(lista2,y21)
#----------------------------------------------------------------------------------
-
#DETERMINANDO A TRANSFORMADA RÁPIDA DE FOURIER e média móvel
x13= freq1[0:800]
y13=dados1[0:800]
x23= freq2[0:800]
y23=dados2[0:800]
F1=(np.fft.fft(y13))
freq1=(np.abs(np.fft.fftfreq(np.size(F1),dt)))
F2=(np.fft.fft(y23))
freq2=(np.abs(np.fft.fftfreq(np.size(F2),dt)))
F2[freq2<0]=0
FF1=((F1))
FF2=((F2))
#---------------------------------------------------------------------------------
#cálculo de média móvel
df1=list(freq1)
df2=list(freq2)
df3=list(np.abs(FF1))
df4=list(np.abs(FF2))
df11 = pd.DataFrame(df1)
df22 = pd.DataFrame(df2)
df33 = pd.DataFrame(df3)
df44 = pd.DataFrame(df4)
data1 = df11.rolling(10).mean()
data2 = df22.rolling(10).mean()
data3 = df33.rolling(10).mean()
data4 = df44.rolling(10).mean()
data1=data1[9: ]
data2=data2[9: ]
data3=data3[9: ]
data4=data4[9: ]
#----------------------------------------------------------------------------------
-
#CÁLCULO DA AMPLITUDE EM (dB)
ampli1=np.array(10*np.log10(data3))
ampli2=np.array(10*np.log10(data4))
#ampli1=np.array(1.0*np.log(data3)) #tirando o db
#ampli2=np.array(1.0*np.log(data4)) #tirando o db
freq=np.array(data1)
#plt.figure(figsize=(15,10),layout="constrained")
plt.plot(freq,ampli1,color='black',label='amostra referência')
#plt.scatter(freq1,amp_1,color='grey')
plt.title('gráfico das amplitude em (dB)')
plt.xlabel("frequência (MHz)")
plt.ylabel("amplitude (dB)")
plt.legend()
plt.plot(freq,ampli2,color='b', label='amostra experimental')
#plt.scatter(freq1,amp_2,color='b')
plt.title('gráfico dos espectros das amplitudes em (dB)')
plt.xlabel("frequência (MHz)")
plt.ylabel("amplitude (dB)")
plt.grid()
plt.legend()
plt.show()
#----------------------------------------------------------------------------------
-
#SELEÇÃO DO INTERVALO DE FREQUÊNCIAS PARA CÁLCULO DA RAZÃO ESPECTRAL
#lim_inf_freq=float(input ('ENTRE COM O MENOR VALOR DA FREQUÊNCIA' ) )
#lim_sup_freq=float(input ('ENTRE COM O MAIOR VALOR DA FREQUÊNCIA' ) )
lim_inf_freq=0.3
lim_sup_freq=1
data1=data1.to_numpy()
data2=data2.to_numpy()
data3=data3.to_numpy()
data4=data4.to_numpy()
raz=data3/data4
lista1=data1
lista2=data3
lista3=data4
nova_lista1=[]
nova_lista2=[]
nova_lista3=[]
for i,j,k in zip(lista1,lista2,lista3):
if(lim_inf_freq<i<lim_sup_freq):
nova_lista1.append(i)
nova_lista2.append(j)
nova_lista3.append(k)
new_freq=nova_lista1
new_ampli1=nova_lista2
new_ampli2=nova_lista3
#----------------------------------------------------------------------------------
-
#MÉTODO DOS MÍNIMOS QUADRADOS
razao_amplitudes=np.log(np.array(new_ampli1) /np.array(new_ampli2))
raz=razao_amplitudes
x=np.array(new_freq)
y=(raz)
n=len(x)
somat1=sum(np.multiply(x,y))
somat2=sum(x)
somat3=sum(np.multiply(x,x))
somat4=sum(y)
a=float((somat2*somat4-n*somat1)/((somat2)**2-n*somat3))
b=float((somat1*somat2-somat3*somat4)/((somat2)**2-n*somat3))
#print('o coef. ang. da reta é a=',a,'e o','o coeficiente linear da reta é b=',b)
x=np.array(new_freq)
#print(type(x))
y1=(raz)
y2=a*x+b
residuo=np.array(y2-y1)
#print(residuo)
desv_pad_residuo=np.std(residuo)
#print(desv_pad_residuo)
plt.title('Gráfico da razão espectral')
plt.xlabel("frequência (MHz)")
plt.ylabel("ln(amp. amostra ref./amp. amostra exp.)")
plt.scatter(x,y,color='b',label='dados experimentais')
#plt.plot(x,raz,color='black')
plt.plot(x,a*x+b,color='red',label='MMQ-Linear')
plt.plot(x,a*x+b+2*desv_pad_residuo,color='darkred',label='intervalo de confiança
de 90%')
plt.plot(x,a*x+b-2*desv_pad_residuo,color='darkred')
plt.legend(prop = {'size' :8})
plt.show()
#----------------------------------------------------------------------------------
-
#CÁLCULO DO FATOR-Q
coef_ang=a
#print(coef_ang)
gama1=(np.pi)/(150.0*vel_amo_alu)
#print('gama da amostra de Alumínio vale:', gama1)
gama2=gama1+0.000001*coef_ang/(L_amo_exp*0.01) #0.01 transformação de cm para m
#print('gama da amostra experimental vale:',gama2)
#Q da amostra
Q2=float((np.pi)/(gama2*vel_amo_exp))
fator_Q=round(Q2,2)
#print("O fator Q da amostra vale:",fator_Q)
#----------------------------------------------------------------------------------
-
#PROPAGAÇÃO DE ERROS do fator Q da amostra
x=np.array(new_freq)
y=(raz)
n=len(x)
m=len(y)
somat_x_y=sum(np.multiply(x,y))
somat_x=sum(x)
somat_x_quad=sum(np.multiply(x,x))
somat_y=sum(y)
somat_y_quad=sum(np.multiply(y,y))
slope=(n*somat_x_y-somat_x*somat_y)/(n*somat_x_quad-somat_x**2)
intercept=(somat_x_quad*somat_y-somat_x*somat_x_y)/(n*somat_x_quad-somat_x**2)
soma=0
for i in range (0,n):
delta_y=y[i]-(a*x[i]+b)
delta_y_quad=delta_y**2
soma=soma+delta_y_quad
sy=np.sqrt( soma/(n-2) )
sa=sy*np.sqrt(n/(n*somat_x_quad-somat_x**2))
sb=sy*np.sqrt(somat_x_quad/(n*somat_x_quad-somat_x**2))
#print('a=',float(slope),'ua=',float(sa))
#print('b=',float(intercept),'ub=',float(sb))
#print('mais cálculos')
L_alu=L_amo_alu*10**-2
L_amo=L_amo_exp*10**-2
st=0.1*10**-6 #desvio do tempo
sL=0.05*10**-3 #desvio do paquímetro
t_alu=(t_1a_que_alu-t_face)*10**-6
t_amo=(t_1a_que_amo-t_face)*10**-6
sv1=math.sqrt( (sL/t_alu)**2+(st*L_alu/(t_alu**2))**2 )
sv2=math.sqrt( (sL/t_amo)**2+(st*L_amo/(t_amo**2))**2 )
#print('os desvios as velocidades são:',sv1,sv2)
sx=0.05*10**-3
comprimento=6.0*10**(-2)
v1=vel_amo_alu
v2=vel_amo_exp
#print ('as velocidades são dadas por:',v1,v2)
# Fator Q do alumínio
Q1=150
xL=L_amo_exp*10**-2
fm=10**-6
newQ2=(((a*v2*fm)/(np.pi*xL)+v2/(v1*Q1))**(-1))
#Q2=(np.pi*xL*Q1*v1)/(a*10**(-6)*v1*v2*Q1+np.pi*xL*v2)
#print('valores das derivadas parciais')
dQ2dxL=(1000000*(np.pi)*a*Q1**2*v1**2*v2)/((a*Q1*v1*v2+1000000*(np.pi)*xL*v2)**2)
#print(dQ2dxL)
dQ2da=-(1000000*(np.pi)*xL*Q1**2*v1**2*v2)/((a*Q1*v1*v2+1000000*(np.pi)*xL*v2)**2)
#print(dQ2da)
dQ2dv1=((1000000**2)*((np.pi)**2)*(xL**2)*Q1*v2)/
((a*Q1*v1*v2+1000000*(np.pi)*xL*v2)**2)
#print(dQ2dv1)
dQ2dv2=-1000000*(np.pi)*xL*Q1*v1*(1000000*(np.pi)*xL+a*Q1*v1)/
((a*Q1*v1*v2+1000000*(np.pi)*xL*v2)**2)
#print(dQ2dv2)
sQ2=np.sqrt( (dQ2da*sa)**2+(dQ2dv1*sv1)**2+(dQ2dv2*sv2)**2+(dQ2dxL*sx)**2 )
sQ2=float(sQ2)
print('os valores são:')
print(round(newQ2,2),round(sQ2,2))
#print('o valor do fator Q da amostra vale: Q=',round(newQ2,2))
#print('a incerteza no valor do fator Q da amostra vale:sQ=','±',round(sQ2,2))
#----------------------------------------------------------------------------------
-
#relatório em pdf
import sys
import io
from PIL import Image
import matplotlib.pyplot as plt
from reportlab.pdfgen import canvas
from reportlab.lib.utils import ImageReader
from reportlab.lib.pagesizes import A4 #folha A4 x=595.27 y=841,89
#----------------------------------------------------------------------------------
---------
# RELATÓRIO EM PDF
#----------------------------------------------------------------------------------
----------------------
nome_pdf = input('Digite um nome para o relatório. ')
pdf = canvas.Canvas('{}.pdf'.format(nome_pdf),pagesize=A4)
#----------------------------------------------------------------------------------
-------------------------
fig1=plt.figure(figsize=(4,2.5),layout="constrained")
plt.subplot(1,1,1)
#plt.title('Gráfico da amostra referência.')
plt.xlabel("tempo (µs)")
plt.ylabel("amplitude (mV)")
plt.grid(True)
plt.plot(x11[0:1000],y11[0:1000],color='black')
fig2=plt.figure(figsize=(4,2.5),layout="constrained")
plt.subplot(1,1,1)
#plt.title('Gráfico da amostra de estudo.')
plt.xlabel("tempo (µs)")
plt.ylabel("amplitude (mV)")
plt.grid(True)
plt.plot(x21[0:1000],y21[0:1000],color='blue')
imgdata1 = io.BytesIO()
fig1.savefig(imgdata1, format='png')
imgdata1.seek(0)
Image1 = ImageReader(imgdata1)
imgdata2 = io.BytesIO()
fig2.savefig(imgdata2, format='png')
imgdata2.seek(0)
Image2 = ImageReader(imgdata2)
pdf.drawInlineImage("logo_gir.png",10,780,width=60,height=60)
pdf.drawString(180,820, 'GIR-Grupo de Inferência de Reservatório')
pdf.drawString(250,800, 'UENF-LENEP')
pdf.drawString(150,760, 'Relatório de análise de experimento de propagação ')
pdf.drawString(170,740, 'de pulso ultrassônico em amostra de rocha.')
import pandas as pd
from datetime import datetime
# Get the current date and time
now = datetime.now()
# Extract the day, month, and year
day = now.day
month = now.month
year = now.year
data=f"{day}/{month}/{year}"
Data="Data:"
pdf.drawString(50,700, f"{Data} {data}")
pdf.drawString(50,650,'Metodologia utilizada para determinação da velocidade de
propagação da onda na amostra:')
pdf.drawString(50,640,'- Comprimento/tempo de chegada.')
pdf.drawString(50,600,'Metodologia utilizada para estimativa do fator de qualidade
da amostra: ')
pdf.drawString(50,590,'- Método da razão espectral.')
pdf.drawString(50,550,'Metolodogia utilizada para estimativa de incertezas no
fator-Q: ')
pdf.drawString(50,540,'- Propagação de erros.')
pdf.drawString(50,500, 'Nome do arquivo do sinal analisado:')
pdf.drawString(50,480,str())
pdf.drawString(50,460, 'Nome do arquivo do sinal registrado na amostra de
referência:')
pdf.drawString(50,440,str())
pdf.drawString(300,10, "página-01")
pdf.showPage()
#----------------------------------------------------------------------------------
-------------------------
pdf.drawString(50,800, 'GRÁFICOS GERADOS:')
pdf.drawString(50,700, 'Gráfico para o sinal da amostra de referência.')
pdf.drawImage(Image1,60,400)
pdf.drawString(50,400, 'Gráfico para o sinal analisado.')
pdf.drawImage(Image2,50,100)
pdf.drawString(300,10, "página-02")
pdf.showPage()
#----------------------------------------------------------------------------------
-------------------------
pdf.drawString(50,800, 'DETERMINAÇÂO DO TEMPO DE 1A QUEBRA:')
pdf.drawString(50,780, 'Tempo de chegada da onda (sinal analisado).')
unit1='µs'
pdf.drawString(50,760,f'{str(t_amo_alu)} {unit1}')
pdf.drawString(50,740, 'Tempo de chegada da onda (sinal amostra de referência).')
pdf.drawString(50,720,f'{str(t_amo_exp) } {unit1}')
pdf.drawString(50,650, 'PARÂMETROS INSERIDOS:')
pdf.drawString(50,630, 'Comprimento das amostras.')
unit2='cm'
pdf.drawString(50,610, f'{str(L_amo_alu) } {unit2}')
pdf.drawString(50,590, 'Tempo face_to_face.')
pdf.drawString(50,570, f'{str(t_face)} {unit1}' )
velocidade_amo_alu=round(v1,2)
velocidade_amo_exp=round(v2,2)
sv1=round(sv1,2)
sv2=round(sv2,2)
#print(velocidade_amo_alu, velocidade_amo_exp)
pdf.drawString(50,530, 'DETERMINAÇÃO DA VELOCIDADE DE PROPAGAÇÃO DA ONDA P NAS
AMOSTRAS:')
var8='V='
unit3='m/s'
unit10='±'
pdf.drawString(50,510, 'Velocidade da onda P na amostra de referência.')
pdf.drawString(50,490, f'{var8} ({str(velocidade_amo_alu)} {unit10} {str(sv1)} )
{unit3} ' )
pdf.drawString(50,470, 'Velocidade da onda P na amostra experimental.')
pdf.drawString(50,450, f'{var8} ({str(velocidade_amo_exp)} {unit10} {str(sv2)})
{unit3}')
fig4=plt.figure(figsize=(4,3),layout="constrained")
plt.plot(freq,ampli1,color='black',label='amostra referência')
#plt.title('gráfico das amplitude (dB)')
plt.xlabel("frequência (MHz)")
plt.ylabel("amplitude (dB)")
plt.legend()
plt.plot(freq,ampli2,color='b', label='amostra experimental')
#plt.title('gráfico da amplitude (dB) em função da frequência')
plt.xlabel("frequência (MHz)")
plt.ylabel("amplitude (dB)")
plt.grid()
plt.legend()
imgdata4 = io.BytesIO()
fig4.savefig(imgdata4, format='png')
imgdata4.seek(0)
Image4 = ImageReader(imgdata4)
pdf.drawString(50,400, 'Gráfico do espectro de amplitude dos sinais:')
pdf.drawImage(Image4,100,80)
pdf.drawString(300, 10, "página-03")
pdf.showPage()
#----------------------------------------------------------------------------------
-------------------------
fig3=plt.figure(figsize=(4,4),layout="constrained")
#plt.title('Gráfico da razão espectral')
plt.xlabel("frequência (MHz)")
plt.ylabel("ln(amp. amostra ref./amp. amostra exp.)")
plt.scatter(x,y,color='b',label='pontos experimentais')
#plt.plot(x,raz,color='black')
plt.plot(x,a*x+b,color='red',label='MMQ-Linear')
plt.plot(x,a*x+b+2*desv_pad_residuo,color='darkred',label='intervalo de confiança
de 90%')
plt.plot(x,a*x+b-2*desv_pad_residuo,color='darkred')
plt.grid()
plt.legend(prop = {'size' :8})
imgdata3 = io.BytesIO()
fig3.savefig(imgdata3, format='png')
imgdata3.seek(0)
Image3 = ImageReader(imgdata3)
pdf.drawString(50,800, 'Gráfico da razão espectral:')
pdf.drawImage(Image3,100,380)
pdf.drawString(50,300, 'Fator de qualidade estimado:')
pdf.drawString(50,280, 'O valor do fator-Q do sinal analisado vale:')
q_fin_parte1=round(newQ2,1)
q_fin_parte2=round(sQ2,1)
#print(q_fin)
var10='Q='
pdf.drawString(50,260, f'{var10} ({str(q_fin_parte1)} {unit10} {q_fin_parte2})')
pdf.drawString(50,200,'Relatório gerado pelo programa PyRockSignal')
pdf.drawString(300, 10, "página-04")
pdf.showPage()
#----------------------------------------------------------------------------------
-------------------------
pdf.save()