ResoluçãodeProblemasdeMínimosQuadradosNãoLinearesparaoCombateàCorrosão - Ipynb - Colaboratory

22/07/22, 11:32 ResoluçãodeProblemasdeMínimosQuadradosNãoLinearesparaoCombateàCorrosão.
ipynb - Colaboratory
Resolução de Problemas de Mínimos Quadrados Não

Lineares para o Combate à Corrosão: Desenvolvendo um
Ambiente Computacional de Divulgação Científica e
Tecnológica.
A partir de então, se iniciará o processo de estudo da resolução de um problema não-linear de
mínimos quadrados através do método de Gauss-Newton.
O problema de corrosão galvânica
se caracteriza pelo acoplamento de dois materias metálicos dissimilares imersos em um
eletrólito, causando uma transferência de carga elétrica de um para o outro, por terem
potenciais elétrolitos diferentes. Neste tipo de cenário, a corrosão ocorre de forma localizada e
próxima à região de acoplamento, ocasionando perfurações no material metálico qye fybcuiba
como anodo.
A técnica de combate à corrosão denominada proteção catódica (PC) consiste em inserir

corrente na estrutura metálica através do eletrólito a fim de reduzir o potencial eletroquímico do
metal. Deste modo, as regiões metálicas naturalmente anódicas se tornam catódicas, evitando
a corrosão.
Para o dimensionamento de um sistema de proteção catódica é importante conhecer as

distribuições de potencial (ϕ ) e de densidade de corrente (i ) na superfície das estruturas
metálicas, tais como as utilizadas na construção das plataformas off-shore, tubulações
enterradas, tanques de armazenamento, navios, entre outras construções.
Simulações numéricas de sistemas de PC podem ser realizadas para reduzir

custos através da
otimização de projetos e determinação de áreas críticas para inspeção. O problema de
potencial eletroquímico é governado pela equação de Poisson com condições de contorno
dadas, geralmente, por relações não lineares entre o potencial e a densidade de corrente. Estas
relações são denominadas curvas de polarização.
No presente trabalho, pretende-se identificar os parâmetros que caracterizam as curvas de

polarização, catódicas e anódicas, a partir da formulação de um problema de quadrados
mínimos não linear. Inicialmente, as curvas de polarização para o catodo e o anodo
consideradas nesta pesquisa são representadas, respectivamente, pelas seguintes equações
não lineares.
Catodo
−1
ϕ = a1 sinh i + b1
Anodo
−1
ϕ = a2 sinh i + b2
https://colab.research.google.com/drive/13662qHF2QwEJlxsb4ej9he1OO0clNAI3?authuser=1#scrollTo=8QWMqpKUpSKe&printMode=true 1/28
22/07/22, 11:32 ResoluçãodeProblemasdeMínimosQuadradosNãoLinearesparaoCombateàCorrosão.ipynb - Colaboratory
onde as dimensões para o potencial eletroquímico ϕ e a densidade de corrente i são,

respectivamente, V e A/m2 .
Para a estimativa das variáveis de projeto a1 , b1 , a2 e b2 , considerando um problema de

quadrados mínimos, é necessário, a partir de ensaios experimentais, o conhecimento de
valores de potencial e corrente. Neste trabalho, inicialmente, os dados considerados
observados são oriundos dos seguintes valores para os parâmetros que caracterizam as
curvas de polarização: a1 = −0.1 V , b1 = 0.7 V , a2 = −1.0 V e b2 = 0.0 V .
Conhecendo os valores de potencial ϕ e densidade de corrente i , as variáveis de projeto podem

ser estimadas, resolvendo o correspondente problema de quadrados mínimos não linear,
através de algoritmos de otimização. Nesta pesquisa, serão considerados um método
determinístico, o Gauss-Newton. A performance das duas estratégias serão analisadas
avaliando custo computacional e precisão, sendo implementadas no software Python.
Método de Newton e Método de Gauss Newton
Como o método de newton as vezes pode não ser aplicável em alguns casos, como quando o
número de pontos dados é diferente da quantidade de parâmetros da função modelo. Então,
usaremos o método de newton para resolver um problema não linear de mínimos quadrados. O
objetivo final será achar os valores para os parâmetros que mais se encaixam na minimização
da segunda norma dos resíduos. logo, minimizaremos
m G(m) i − di
f (m) = ∑ ( )
i=1
σi
F i (m)
⎡ ⎤
⎢ . ⎥
⎢ ⎥
⎢ ⎥
⎢ . ⎥
⎢ ⎥
⎢ . ⎥
⎣ ⎦
F m (m)
O método implementado funciona de tal forma que a interpolação não-linear é feita até que se
atinja uma diferênça entre a curva modelo e os pontos discretizados. Tal diferença é chamada
de resíduo. Abaixo, podemos visualizar como funciona uma interpolação simples.
from re import A
import matplotlib.pyplot as plt
import matplotlib.animation
import numpy as np
import random
t = np.linspace(0,2*np.pi)
x = np.sin(t)
a=[0.33069, 0.66139, 0.99208 , 1.9842 ,2.3149, 2.6456 , 3.3069, 3.6376, 3.9683
fig, ax = plt.subplots()
plt.style.use('ggplot')
ax.axis([0,2*np.pi,-1,1])
l, = ax.plot([],[],'--', linewidth=2, markersize=12)
j, = ax.plot(a,np.sin(a),'bo',color='red',)
def animate(i):
l.set_data(t[:i], x[:i])

from IPython.display import HTML
ani = matplotlib.animation.FuncAnimation(fig, animate, frames=len(t))
HTML(ani.to_jshtml())










Once

Loop

Reflect
Condição de Armijo
O que será utilizado pra garantir o decrescimento da F (x) é a chamada Condição de Armijo,
que consiste em tomar um ponto arbitrário e sua derivada direcional na direção d da função F .
Lembrando que para, uma direção de descida d , a função decresça, a ∂ f /∂ d < 0 , então ao
querer chegar no mínimo da função, teremos ∂ f /∂ d = 0 . Portanto, basta que escolhamos um
αk ∈)0, 1(|∂ f /∂ d ⋅ αk → 0 O que garante o caminho de decrescimento de F .
!pip install ffmpeg-python
!pip install celluloid
Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/

Collecting ffmpeg-python
Downloading ffmpeg_python-0.2.0-py3-none-any.whl (25 kB)
Requirement already satisfied: future in /usr/local/lib/python3.7/dist-packages (fro

Installing collected packages: ffmpeg-python
Successfully installed ffmpeg-python-0.2.0
Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/

Collecting celluloid
Downloading celluloid-0.2.0-py3-none-any.whl (5.4 kB)
Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages

Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist
Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-package
Requirement already satisfied: numpy>=1.11 in /usr/local/lib/python3.7/dist-packages
Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-pa
Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/loca
Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-pa
Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (f
Installing collected packages: celluloid
Successfully installed celluloid-0.2.0
E=[-50,-45,-40,-35,-30,-25,-20,-15,-10]
iE=[-1.25252,-1.01743,-0.74747,-0.41947,0.00000,0.55940,1.32936,2.41308,3.96163]
fig=plt.figure()
#plt.xlim(-40,-10)
#plt.ylim(-1.5,5)
plt.xlabel('E (mV)')
plt.ylabel('i (� A)')
plt.plot(E, iE , 'ro', label='Data')
plt.legend()
<matplotlib.legend.Legend at 0x7fe1a5ee3a10>
Objetivo Principal
Nosso objetivo é, a partir de uma função modelo, minimizar o ϵ entre a função modelo e os
pontos discretizados dos parâmetros E e iE. Isso será feito na curva i através dos parâmetros
βa , Ec , ic e βc que ao serem ajustados pelo Método de Gauss Newton, vão se adequar aos
pontos fornecidos. Através da função:
2.303(E−Ec ) 2.303(Ec −E)
βa βc
i = i c [e − e ]
Lembrando que E é um dos dados já fornecidos.
Método Gauss-Newton em Python

Para dar início ao programa, iremos realizar a importação das bibliotecas necessárias para o
programa:
Primeiro ciclo do programa
import numpy
import numpy as np
import math
from datetime import datetime
import time
from celluloid import Camera # importando a camera
from random import randint
from matplotlib.animation import FuncAnimation
import pandas as pd
from IPython.display import HTML
Apresentações:
print(' O METODO DE GAUSS-NEWTON ')
print('Discente de IC: Gabriel Fernandes')
print('Orientador: Wilian Santos')
print('Contato: wilianj@ufrrj.br')
print(datetime.now())
O METODO DE GAUSS-NEWTON
Discente de IC: Gabriel Fernandes
Orientador: Wilian Santos
Contato: wilianj@ufrrj.br
2022-07-20 13:14:53.396166
Dados iniciais:
#initial data
E=[-50,-45,-40,-35,-30,-25,-20,-15,-10]
iE=[-1.25252,-1.01743,-0.74747,-0.41947,0.00000,0.55940,1.32936,2.41308,3.96163]
tol=0.0000001 #tolerance!!
nmax=500 #max number of iterations
#Step lenght - Armijo condition
alpha_k=1 #tivemos q diminuir o alpha inicial para 1, mudou tb o chute inicial
theta=0.1
c1=0.0001
Definindo os vetores e matrizes utlilizados no programa
#def auxiliar vectors and len max of initial data
auxba=[] #= 30; Tafel slope (mV)
auxbc=[] #= 120; Tafel slope (mV)
auxic=[] #ic = 1; % corrosion current(\mu A)
auxEc=[] #Ec=-30; %corrosion potential (mV)
auxa=[]
auxc=[]
iEest=[]
F=[]
res=[]
J = np.zeros((len(E), 4)) #len of Jacobian Matrix
nvar = len(E)
Definindo os chutes iniciais

O próximo passo consiste em dar o chute inicial para as váriaveis
ini = time.time()
#Initial solution for the design variables (\beta_a,\beta_c)
auxba.append(10) #= 30; Tafel slope (mV)
auxbc.append(10) #= 120; Tafel slope (mV)
auxic.append(10) #ic = 1; % corrosion current(\mu A)
auxEc.append(10) #Ec=-30; %corrosion potential (mV)

Função modelo escolhida

Tomemos agora o seguinte modelo para a curva de polarização:
2.303(E−Ec ) 2.303(Ec −E)
βa βc
i = i c [e − e ]
#Objective function
for i in range(nvar):
auxa.append(math.exp((2.303 * (E[i]-auxEc[0])/auxba[0])))
auxc.append(math.exp((2.303 * (auxEc[0]-E[i])/auxbc[0])))
iEest.append( auxic[0] * (auxa[i] - auxc[i]))
E abaixo será aplicado de fato o processo de mínimos quadrados para o termo #0 de F e

também o resíduo.
F.append(0.0)
for k in range(nvar):
res.append(iEest[k] - iE[k]) #residue
F[0] = F[0] + 0.5*(res[k])**2
Matriz Jacobiana
Abaixo, será calculada a matriz jacobiana da Função:
#Jacobian matrix
J[k,0] = - auxic[0] * math.exp(2.303*(E[k]-auxEc[0])/auxba[0]) * 2.303 * (E[k]-auxEc[
J[k,1] = auxic[0] * 2.7183**(2.303*(auxEc[0]-E[k])/auxbc[0]) * 2.303 * (auxEc[0]-E[k]
J[k,2] = 2.7183**(2.303*(E[k]-auxEc[0])/auxba[0]) -2.7183**(2.303*(auxEc[0]-E[k])/aux
J[k,3] = auxic[0] * ( 2.7183**(2.303*(E[k]-auxEc[0])/auxba[0])* (-2.303/auxba[0])-2.71
Segundo Ciclo do Programa
Processo iterativo
Todo o processo realizado até então, consiste na primeira parte do processo de resolução de
problemas de programação não linear através do método de Gauss-Newton. A definição dos
chutes iniciais, a identificação de qual função se assemelha aos dados discretizados obtidos, e
também a construção da matriz jacobiana, são aspectos fundamentais para a resolução do
P.P.N.L.
A partir de agora, daremos início ao processo iterativo do Método de Gauss-Newton.

contador=0
while (F[contador] > tol) and (contador < nmax) :

transposta_J=np.transpose(J)

transposta_res=np.transpose(res)

Hess = numpy.dot( transposta_J , J) #Hessian (G-N) matrix

pseudo_inv_Hess=np.linalg.pinv(Hess)

GradF = numpy.dot( transposta_J , transposta_res) #Gradient

pk = numpy.dot(- pseudo_inv_Hess , GradF) #Descendent direction (G-N)

contador=contador+1

#Iteration
auxba.append(auxba[contador-1] + alpha_k * pk[0])
auxbc.append(auxbc[contador-1] + alpha_k * pk[1])
auxic.append(auxic[contador-1] + alpha_k * pk[2])
auxEc.append(auxEc[contador-1] + alpha_k * pk[3])

#Objective function
for k in range (nvar):
auxa[k]=math.exp((2.303 * (E[k]-auxEc[contador])/auxba[contador]))
auxc[k]=(math.exp((2.303 * (auxEc[contador]-E[k])/auxbc[contador])))
iEest[k] = auxic[contador] * (auxa[k] - auxc[k])

F.append(0)

for c in range(0,nvar):
res[c] = (iEest[c] - iE[c])
F[contador]=F[contador] + 0.5*(res[c])**2

if (any(F[contador] > (F[contador-1] + c1 * alpha_k * np.transpose(GradF) * pk))):

alpha_k=alpha_k * theta

auxba[contador]=auxba[contador-1] + alpha_k * pk[0]
auxbc[contador]=auxbc[contador-1] + alpha_k * pk[1]
auxic[contador]=auxic[contador-1] + alpha_k * pk[2]
auxEc[contador]=auxEc[contador-1] + alpha_k * pk[3]

#Objective function


F.append(0)


#Jacobian matrix
for k in range(0,nvar):
J[k,0] = - auxic[contador] * math.exp(2.303*(E[k]-auxEc[contador])/auxba[cont
J[k,1] = auxic[contador] * 2.7182**(2.303*(auxEc[contador]-E[k])/auxbc[contad
J[k,2] = 2.7182**(2.303*(E[k]-auxEc[contador])/auxba[contador]) -2.7182**(2.3
J[k,3] = auxic[contador] * ( 2.7182**(2.303*(E[k]-auxEc[contador])/auxba[conta

resto= contador%5
if resto == 0 :
auxE1= np.arange(-50,-9.9,0.1)
iEest1=[]
auxa=[]
auxc=[]
for k in range(len(auxE1)):
auxa.append(math.exp(2.303*(auxE1[k]-auxEc[contador])/auxba[contador]))
auxc.append(math.exp(2.303*(auxEc[contador]-auxE1[k])/auxbc[contador]))
iEest1.append(auxic[contador] * (auxa[k] - auxc[k]))

#Image Interpolation
#auxPlot= np.arange(0,contador+1,1)
#plt.style.use('ggplot')
#plt.figure()
#plt.xlim(-55,-5)
#plt.ylim(-3,6)
#plt.xlabel('E (mV)')
#plt.ylabel('i (� A)')
#plt.plot([-50,-45,-40,-35,-30,-25,-20,-15,-10], [-1.25252,-1.01743,-0.74747,-0
#plt.plot(auxE1, iEest1 , color='black',linewidth=2, markersize=1,label='Fit')
#plt.legend()
fim = time.time()
#End program
Resultados Obtidos
Após o processo iterativo, atingiremos uma tolerância já fornecida pelo usuário ou um número
máximo de iterações, e então os dados serão exibidos abaixo:
print('\n \n')
df = pd.DataFrame(data=[[format(fim-ini, '.3f')],[format(contador+1, '.0f')]],index=['Elap
print(df)
print('\n \n')
d = {'Pot. (mV)': E, 'Corrente': iE, '\mu A': iEest}
df = pd.DataFrame(data=d)
print(df)
print('\n \n')
d = {'GradF':GradF}
print(df)
print('\n \n')
df = pd.DataFrame(data=[ auxba[contador] ,
auxbc[contador] ,
auxic[contador],
auxEc[contador]], index=['auxba','auxbc','auxic','auxEc'], column
print(df)
print('\n \n')
print(' \t Fim de execução.')
print('\n \n')
Elapsed time (sec) 0.233
Número de iterações 22
Pot. (mV) Corrente \mu A
0 -50 -1.25252 -1.252520
1 -45 -1.01743 -1.017430
2 -40 -0.74747 -0.747475
3 -35 -0.41947 -0.419467
4 -30 0.00000 0.000001
5 -25 0.55940 0.559400
6 -20 1.32936 1.329359
7 -15 2.41308 2.413080
8 -10 3.96163 3.961630
GradF
0 -0.000053
1 -0.000004
2 0.001700
3 -0.000041
Variáveis de projeção ótima
auxba 29.999956
auxbc 119.998197
auxic 0.999996
auxEc -30.000014
Fim de execução.
Imprimindo novos pontos para que a função interpolada seja plotada:
#impress new points
auxxx = [-38.0,-27.0] #new potential
auxiEest=[]
auxiEexat=[]
#estimado
for k in range (len(auxxx)):

auxa.append(math.exp(2.303 * (auxxx[k]-auxEc[contador])/auxba[contador]))
auxc.append(math.exp(2.303 * (auxEc[contador]-auxxx[k])/auxbc[contador]))
auxiEest.append( auxic[contador] * (auxa[k] - auxc[k])) #Estimated with the new points
##exato
auxa.append(math.exp(2.303 * (auxxx[k]-auxEc[contador])/30.0))
auxc.append(math.exp(2.303 * (auxEc[contador]-auxxx[k])/120.0))
auxiEexat.append(auxic[contador] * (auxa[k] - auxc[k])) #Exact with the new points
Plotando os gráficos:
iEest1=[]
auxa=[]
auxc=[]
auxPlot= np.arange(0,contador+1,1)
Imagem 1: Curva Interpolada
#Image 1
plt.figure()
#plt.xlim(-40,-10)
#plt.ylim(-1.5,5)
plt.plot(E, iE , 'ro', label='Data')
plt.plot(auxE1, iEest1 , color='black',linewidth=2, markersize=1,label='Fit')
plt.legend()
<matplotlib.legend.Legend at 0x7fe1a5e9d490>
Imagem 2:
#Image 2
plt.figure()
plt.ylim(10,35)
plt.xlim(0,25)
plt.xlabel('Iteration')
plt.ylabel('Anodic Tafel slope')
plt.plot(auxPlot, auxba , 'ro')
plt.plot(auxE1, iEest1 , color='black',linewidth=2, markersize=1)
[<matplotlib.lines.Line2D at 0x7fe19f496650>]
Imagem 3:
#Image 3
plt.figure()
plt.ylim(0,120)
plt.xlim(0,25)
plt.ylabel('Cathodic Tafel slope')
plt.plot(auxPlot, auxbc , 'ro')
[<matplotlib.lines.Line2D at 0x7fe19f44de90>]
Imagem 4:
#Image 4
plt.figure()
ax = plt.axes()
plt.xlim(0,30)
plt.ylim(-40,10)
plt.ylabel('Corrosion potential')
plt.plot( auxPlot , auxEc, 'ro')
[<matplotlib.lines.Line2D at 0x7fe19f3d4790>]
Imagem 5:
#Image 5
plt.figure()
ax = plt.axes()
plt.xlim(0,25)
plt.ylim(0,25)
plt.ylabel('Corrosion current')
plt.plot( auxPlot , auxic, 'ro')
[<matplotlib.lines.Line2D at 0x7fe19f4380d0>]
Testes acerca do Método Gauss-Newton

A partir de então daremos início ao processo de testes com o código implementado na
linguagem de programação Python para analisarmos o comportamento do método G-N através
do programa.
O que acontece quando mudamos os chutes iniciais?
A condição de Armijo garante sempre o decrescimento da função?
O método sempre garante que encontremos um ótimo?
Essas e algumas outras perguntas serão respondidas a partir de então.
Teste com chutes iniciais randômicos

Nesse teste usaremos a função RAND do python para gerar chutes iniciais randômicos, tendo a
função
2.303(E−Ec ) 2.303(Ec −E)
i = i c [e βa
− e βc
]
gerando valores aleatórios para ic , βa , Ec e βc , e a partir disso, vamos observar os resultados.
O programa irá rodar 10 vezes, cada vez com seus ic , βa , Ec e βc diferentes em um intervalo
[10, 20] .
#The Gauss-Newton (G-N) method for minimizing a nonlinear objective function
import numpy
import numpy as np
import math
import time
import pandas as pd
import random
NVPRMCI=0
timing=[]
Numb_iter=[]
guarda_auxba=[]
guarda_auxbc=[]
guarda_auxic=[]
guarda_auxEc=[]
for k in range(10):
NVPRMCI=NVPRMCI+1
#print(' O METODO DE GAUSS-NEWTON ')
#print('Discente de IC: Gabriel Fernandes')
#print('Orientador: Wilian Santos')
##print('Contato: wilianj@ufrrj.br')
#print(datetime.now())

#Data (9)
E=[-50,-40,-35,-30,-25,-20,-10]
iE=[-1.25252,-0.74747,-0.41947,0.00000,0.55940,1.32936,3.96163]

nmax=499

theta=0.1
c1=0.0001

#def auxiliar vectors
auxa=[]
auxc=[]
iEest=[]
F=[]
res=[]
J = np.zeros((7, 4))
nvar = len(E)

ini = time.time()
auxba.append(random.randint(10, 20)) #= 30; Tafel slope (mV)
auxbc.append(random.randint(10, 20)) #= 120; Tafel slope (mV)
auxic.append(random.randint(10, 20)) #ic = 1; % corrosion current(\mu A)
auxEc.append(random.randint(10, 20)) #Ec=-30; %corrosion potential (mV)

guarda_auxba.append(auxba[0])
guarda_auxbc.append(auxbc[0])
guarda_auxic.append(auxic[0])
guarda_auxEc.append(auxEc[0])

#Objective function

F.append(0.0)

F[0] = F[0] + 0.5*(res[k])**2

#Jacobian matrix #descobrir como construir uma matriz jacobiana mais fácil no python
J[k,0] = - auxic[0] * math.exp(2.303*(E[k]-auxEc[0])/auxba[0]) * 2.303 * (E[k]-au
J[k,1] = auxic[0] * 2.7183**(2.303*(auxEc[0]-E[k])/auxbc[0]) * 2.303 * (auxEc[0]-
J[k,2] = 2.7183**(2.303*(E[k]-auxEc[0])/auxba[0]) -2.7183**(2.303*(auxEc[0]-E[k])
J[k,3] = auxic[0] * ( 2.7183**(2.303*(E[k]-auxEc[0])/auxba[0])* (-2.303/auxba[0])-

contador=0








contador=contador+1

#Iteration

#Objective function


F.append(0)


if (any(F[contador] > (F[contador-1] + c1 * alpha_k * np.transpose(GradF) * pk



#Objective function


F.append(0)


#Jacobian matrix

J[k,0] = - auxic[contador] * math.exp(2.303*(E[k]-auxEc[contador])/auxba[
J[k,1] = auxic[contador] * 2.7182**(2.303*(auxEc[contador]-E[k])/auxbc[co
J[k,2] = 2.7182**(2.303*(E[k]-auxEc[contador])/auxba[contador]) -2.7182**
J[k,3] = auxic[contador] * ( 2.7182**(2.303*(E[k]-auxEc[contador])/auxba[c

fim = time.time()
#End program

#print('\n \n')
Numb_iter.append(contador+1)
#df = pd.DataFrame(data=[[format(fim-ini, '.3f')],[format(contador+1, '.0f')]],index=[
#print(df)

#print('\n \n')
#d = {'Pot. (mV)': E, 'Corrente': iE, '\mu A': iEest}
#df = pd.DataFrame(data=d,index=['','','','','','',''])
#print(df)

#print('\n \n')

#d = {'GradF':GradF}
#df = pd.DataFrame(data=d,index=['','','',''])
#print(df)

#print('\n \n')

#df = pd.DataFrame(data=[ auxba[contador] ,
#auxbc[contador] ,
#auxic[contador],
#auxEc[contador]], index=['auxba','auxbc','auxic','auxEc'], c

#print(df)

#print('\n \n')

#print(' \t Fim de execução.')
#print('\n \n')

#para imprimir novos pontos
auxxx = [-38.0,-27.0] #potencial novo
auxiEest=[]
auxiEexat=[]
#estimado

auxiEest.append( auxic[contador] * (auxa[k] - auxc[k])) #estimado com os novos pon
##exato
auxiEexat.append(auxic[contador] * (auxa[k] - auxc[k])) #exato com os novos pontos

timing.append(fim-ini)

print('\n \n')
print('\n \n')
d = {'auxba inicial': guarda_auxba, 'auxbc inicial': guarda_auxbc,'auxic inicial': guarda_
print(df)

print('\n \n')
auxba inicial auxbc inicial auxic inicial auxEc inicial Num Iter \
0 13 15 14 14 17
1 13 18 17 12 166
2 15 18 14 12 182
3 19 20 18 10 16
4 13 20 19 14 178
5 20 18 12 17 16
6 19 14 13 10 19
7 20 12 10 16 21
8 15 19 10 11 173
9 14 18 14 18 155
Tempo
0 0.003608
1 0.026692
2 0.030414
3 0.002765
4 0.030035
5 0.002953
6 0.003144
7 0.003432
8 0.033840
9 0.033992
Teste de retirada de pontos

Neste caso, iremos retirar alguns pontos de E e iE para poder analisar se os parâmetros
i c , βa , Ec e βc continuam convergindo para os mesmos valores quando tínhamos todos os
pontos de E e iE.
Sendo:
E = [−50, −45, −40, −35, −30, −25, −20, −15, −10]
iE = [−1.25252, −1.01743, −0.74747, −0.41947, 0.00000, 0.55940, 1.32936, 2.41308,
Tal que após retirar alguns pontos, ficamos com:
E = [−50, −40, −35, −25, −20, −10]
iE = [−1.25252, −0.74747, −0.41947, 0.55940, 1.32936, 3.96163]
#The Gauss-Newton (G-N) method for minimizing a nonlinear objective function
import numpy
import numpy as np
import math
from datetime import datetime
import time
import pandas as pd
print(' O METODO DE GAUSS-NEWTON ')
print('Discente de IC: Gabriel Fernandes')
print('Orientador: Wilian Santos')
print('Contato: wilianj@ufrrj.br')
print(datetime.now())
#Data (9)
E=[-50,-40,-35,-25,-20,-10]
iE=[-1.25252,-0.74747,-0.41947,0.55940,1.32936,3.96163]
nmax=499
theta=0.1
c1=0.0001
#def auxiliar vectors
auxa=[]
auxc=[]
iEest=[]
F=[]
res=[]
J = np.zeros((len(E), 4))
nvar = len(E)
ini = time.time()
auxba.append(10) #= 30; Tafel slope (mV)
auxbc.append(10) #= 120; Tafel slope (mV)
auxic.append(10) #ic = 1; % corrosion current(\mu A)
auxEc.append(10) #Ec=-30; %corrosion potential (mV)

#Objective function
F.append(0.0)
F[0] = F[0] + 0.5*(res[k])**2
#Jacobian matrix #descobrir como construir uma matriz jacobiana mais fácil no python
J[k,0] = - auxic[0] * math.exp(2.303*(E[k]-auxEc[0])/auxba[0]) * 2.303 * (E[k]-auxEc[
J[k,1] = auxic[0] * 2.7183**(2.303*(auxEc[0]-E[k])/auxbc[0]) * 2.303 * (auxEc[0]-E[k]
J[k,2] = 2.7183**(2.303*(E[k]-auxEc[0])/auxba[0]) -2.7183**(2.303*(auxEc[0]-E[k])/aux
J[k,3] = auxic[0] * ( 2.7183**(2.303*(E[k]-auxEc[0])/auxba[0])* (-2.303/auxba[0])-2.71
contador=0







contador=contador+1

#Iteration

#Objective function

F.append(0)


if (any(F[contador] > (F[contador-1] + c1 * alpha_k * np.transpose(GradF) * pk))):



#Objective function


F.append(0)


#Jacobian matrix
J[k,0] = - auxic[contador] * math.exp(2.303*(E[k]-auxEc[contador])/auxba[cont
J[k,1] = auxic[contador] * 2.7182**(2.303*(auxEc[contador]-E[k])/auxbc[contad
J[k,2] = 2.7182**(2.303*(E[k]-auxEc[contador])/auxba[contador]) -2.7182**(2.3
J[k,3] = auxic[contador] * ( 2.7182**(2.303*(E[k]-auxEc[contador])/auxba[conta

resto= contador%3
if resto == 0 :
iEest1=[]
auxa=[]
auxc=[]
#Image 1
plt.figure()
plt.xlim(-40,-10)
plt.ylim(-1.5,5)
plt.plot([-50,-45,-40,-35,-30,-25,-20,-15,-10], [-1.25252,-1.01743,-0.74747,-0.
, 'ro', label='Data')
plt.legend()

fim = time.time()
#End program
print('\n \n')
df = pd.DataFrame(data=[[format(fim-ini, '.3f')],[format(contador+1, '.0f')]],index=['Elap
print(df)
print('\n \n')
d = {'Pot. (mV)': E, 'Corrente': iE, '\mu A': iEest}
print(df)
print('\n \n')
d = {'GradF':GradF}
print(df)
print('\n \n')
df = pd.DataFrame(data=[ auxba[contador] ,
auxbc[contador] ,
auxic[contador],
auxEc[contador]], index=['auxba','auxbc','auxic','auxEc'], column
print(df)
print('\n \n')
print(' \t Fim de execução.')
print('\n \n')
#para imprimir novos pontos
auxxx = [-38.0,-27.0] #potencial novo
auxiEest=[]
auxiEexat=[]
#estimado

auxiEest.append( auxic[contador] * (auxa[k] - auxc[k])) #estimado com os novos pontos
##exato
auxiEexat.append(auxic[contador] * (auxa[k] - auxc[k])) #exato com os novos pontos
#Plotting
iEest1=[]
auxa=[]
auxc=[]
EOriginal=[-50,-45,-40,-35,-30,-25,-20,-15,-10]
iEOriginal=[-1.25252,-1.01743,-0.74747,-0.41947,0.00000,0.55940,1.32936,2.41308,3.96163]
#Image 1
plt.figure()
plt.plot(EOriginal, iEOriginal , 'ro', label='Data')
plt.legend()
#Image 2
plt.figure()
plt.ylabel('Anodic Tafel slope')
plt.plot(auxPlot, auxba , 'ro', label='Betha_a s Research convergence ')
plt.legend()
#Image 3
plt.figure()
plt.ylabel('Cathodic Tafel slope')
plt.plot(auxPlot, auxbc , 'ro', label='Betha_c s Research convergence ')
plt.legend()
#Image 4
plt.figure()
ax = plt.axes()
plt.ylabel('Corrosion potential')
plt.plot( auxPlot , auxEc, 'ro',label='E_c s Research convergence ')
plt.legend()
#Image 5
plt.figure()
ax = plt.axes()
plt.ylabel('Corrosion current')
plt.plot( auxPlot , auxic, 'ro',label='E_ic s Research convergence ')
plt.legend()
O METODO DE GAUSS-NEWTON
Discente de IC: Gabriel Fernandes
Orientador: Wilian Santos
Contato: wilianj@ufrrj.br
2022-07-22 13:25:47.459126
Então,Elapsed
após rodar
timeo(sec)
programa, percebemos que não só os parâmetros ic , βa , Ec e βc
0.162
Número odemesmo
mantiveram iterações 22
valor, mas que o número de iterações se manteve igual, o que indica um

bom funcionamento

do programa.
Pot. (mV) Corrente \mu A
0 -50 -1.25252 -1.252521
1 -40 -0.74747 -0.747475
2 -35 -0.41947 -0.419467
3 -25 0.55940 0.559401
4 -20 1.32936 1.329359
5 -10 3.96163 3.961631
GradF
0 -0.000075
1 -0.000005
2 0.002418
3 -0.000056
Variáveis de projeção ótima
auxba 29.999932
auxbc 119.997234
auxic 0.999993
auxEc -30.000020
check 1s conclusão: 11:21

ResoluçãodeProblemasdeMínimosQuadradosNãoLinearesparaoCombateàCorrosão - Ipynb - Colaboratory

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

ResoluçãodeProblemasdeMínimosQuadradosNãoLinearesparaoCombateàCorrosão - Ipynb - Colaboratory

Enviado por

Direitos autorais:

Formatos disponíveis

22/07/22, 11:32 ResoluçãodeProblemasdeMínimosQuadradosNãoLinearesparaoCombateàCorrosão.

Resolução de Problemas de Mínimos Quadrados Não

A técnica de combate à corrosão denominada proteção catódica (PC) consiste em inserir

Para o dimensionamento de um sistema de proteção catódica é importante conhecer as

Simulações numéricas de sistemas de PC podem ser realizadas para reduzir

No presente trabalho, pretende-se identificar os parâmetros que caracterizam as curvas de

onde as dimensões para o potencial eletroquímico ϕ e a densidade de corrente i são,

Para a estimativa das variáveis de projeto a1 , b1 , a2 e b2 , considerando um problema de

Conhecendo os valores de potencial ϕ e densidade de corrente i , as variáveis de projeto podem

Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/

Downloading ffmpeg_python-0.2.0-py3-none-any.whl (25 kB)

Requirement already satisfied: future in /usr/local/lib/python3.7/dist-packages (fro

Successfully installed ffmpeg-python-0.2.0

Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/

Downloading celluloid-0.2.0-py3-none-any.whl (5.4 kB)

Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages

Successfully installed celluloid-0.2.0

Lembrando que E é um dos dados já fornecidos.

Método Gauss-Newton em Python

Primeiro ciclo do programa

Definindo os vetores e matrizes utlilizados no programa

Definindo os chutes iniciais

Função modelo escolhida

E abaixo será aplicado de fato o processo de mínimos quadrados para o termo #0 de F e

Segundo Ciclo do Programa

A partir de agora, daremos início ao processo iterativo do Método de Gauss-Newton.

Elapsed time (sec) 0.233

Pot. (mV) Corrente \mu A

0 -50 -1.25252 -1.252520

1 -45 -1.01743 -1.017430

2 -40 -0.74747 -0.747475

3 -35 -0.41947 -0.419467

4 -30 0.00000 0.000001

5 -25 0.55940 0.559400

6 -20 1.32936 1.329359

7 -15 2.41308 2.413080

8 -10 3.96163 3.961630

Variáveis de projeção ótima

Imprimindo novos pontos para que a função interpolada seja plotada:

Imagem 1: Curva Interpolada

Testes acerca do Método Gauss-Newton

O que acontece quando mudamos os chutes iniciais?

A condição de Armijo garante sempre o decrescimento da função?

O método sempre garante que encontremos um ótimo?

Essas e algumas outras perguntas serão respondidas a partir de então.

Teste com chutes iniciais randômicos

gerando valores aleatórios para ic , βa , Ec e βc , e a partir disso, vamos observar os resultados.

Teste de retirada de pontos

iE = [−1.25252, −1.01743, −0.74747, −0.41947, 0.00000, 0.55940, 1.32936, 2.41308,

Tal que após retirar alguns pontos, ficamos com:

E = [−50, −40, −35, −25, −20, −10]

iE = [−1.25252, −0.74747, −0.41947, 0.55940, 1.32936, 3.96163]

valor, mas que o número de iterações se manteve igual, o que indica um

Pot. (mV) Corrente \mu A

0 -50 -1.25252 -1.252521

1 -40 -0.74747 -0.747475

2 -35 -0.41947 -0.419467

3 -25 0.55940 0.559401

4 -20 1.32936 1.329359

5 -10 3.96163 3.961631

Variáveis de projeção ótima

check 1s conclusão: 11:21