MateWiki - Contribuciones del usuario [es]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T22:16:28Z

Nacho:

{{ TrabajoED | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=

[[Archivo:Poster MNEDP 2025 CAD 2.jpg|1000px]]

También es posible [https://objectstorage.eu-madrid-3.oraclecloud.com/n/axfzuuzt6hgr/b/bucket-20251109-1118/o/Poster_MNEDP.pdf ver el póster en PDF a resolución completa]. Se puede acceder a los contenidos del código QR mediante [https://upm365-my.sharepoint.com/:f:/g/personal/ignacio_mcerezo_alumnos_upm_es/ErKozPkziC1Libi_AA5ymBcBUvtgf0WEWuWRrldhSUmfuA?e=ADGVcV este enlace].

=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: calculate_con_mesh_params.m ==
Este código se encarga de escoger unos parámetros concretos para el mallado a partir de un valor concreto de <math>h</math>.
<syntaxhighlight lang="MATLAB">
function [ntheta_inner, ntheta_outer, nr_inner, nr_outer] = calculate_con_mesh_params(h, R, r1)
%calcula los parámetros de generate_mesh necesarios para conseguir una
%cierta "h" (es un poco heurístico e impreciso, pero funciona!)
circum_inner = 2*pi*r1;
circum_outer = 2*pi*R;

%divisiones angulares
ntheta_inner = max(3, ceil(circum_inner / h));
ntheta_outer = max(3, ceil(circum_outer / h));

%divisiones de tipo anillo
nr_inner = max(1, ceil(r1 / h));
nr_outer = max(1, ceil((R - r1) / h));
end

</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h</math> concreta y una "excentricidad" dada.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
Este código representa el mallado que hemos generado con las funciones anteriores, diferenciando en las dos regiones <math>\Omega_1</math> y <math>\Omega_2</math>.
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
Este código representa la solución que calculan los códigos posteriores.
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
Este código ensambla el sistema lineal que resulta del método de elementos finitos.
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
La función principal, aplica las funciones anteriores a un problema concreto, generando el mallado y usándolo con una <math>f</math> concreta, definida en el mismo código.
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Archivo:Poster MNEDP 2025 CAD 2.jpg

2025-11-16T22:15:23Z

Nacho: Segunda versión de Poster MNEDP 2025 CAD.jpg

Segunda versión de Poster MNEDP 2025 CAD.jpg

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T21:58:34Z

Nacho:

{{ TrabajoED | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=

[[Archivo:Poster MNEDP 2025 CAD.jpg|1000px]]

También es posible [https://objectstorage.eu-madrid-3.oraclecloud.com/n/axfzuuzt6hgr/b/bucket-20251109-1118/o/Poster_MNEDP_2025_CAD.pdf ver el póster en PDF a resolución completa]. Se puede acceder a los contenidos del código QR mediante [https://upm365-my.sharepoint.com/:f:/g/personal/ignacio_mcerezo_alumnos_upm_es/ErKozPkziC1Libi_AA5ymBcBUvtgf0WEWuWRrldhSUmfuA?e=ADGVcV este enlace].

=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: calculate_con_mesh_params.m ==
Este código se encarga de escoger unos parámetros concretos para el mallado a partir de un valor concreto de <math>h</math>.
<syntaxhighlight lang="MATLAB">
function [ntheta_inner, ntheta_outer, nr_inner, nr_outer] = calculate_con_mesh_params(h, R, r1)
%calcula los parámetros de generate_mesh necesarios para conseguir una
%cierta "h" (es un poco heurístico e impreciso, pero funciona!)
circum_inner = 2*pi*r1;
circum_outer = 2*pi*R;

%divisiones angulares
ntheta_inner = max(3, ceil(circum_inner / h));
ntheta_outer = max(3, ceil(circum_outer / h));

%divisiones de tipo anillo
nr_inner = max(1, ceil(r1 / h));
nr_outer = max(1, ceil((R - r1) / h));
end

</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h</math> concreta y una "excentricidad" dada.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
Este código representa el mallado que hemos generado con las funciones anteriores, diferenciando en las dos regiones <math>\Omega_1</math> y <math>\Omega_2</math>.
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
Este código representa la solución que calculan los códigos posteriores.
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
Este código ensambla el sistema lineal que resulta del método de elementos finitos.
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
La función principal, aplica las funciones anteriores a un problema concreto, generando el mallado y usándolo con una <math>f</math> concreta, definida en el mismo código.
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T21:55:32Z

Nacho:

{{ TrabajoED | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=

[[Archivo:Poster MNEDP 2025 CAD.jpg]]

También es posible [https://objectstorage.eu-madrid-3.oraclecloud.com/n/axfzuuzt6hgr/b/bucket-20251109-1118/o/Poster_MNEDP_2025_CAD.pdf ver el póster en PDF a resolución completa].

=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: calculate_con_mesh_params.m ==
Este código se encarga de escoger unos parámetros concretos para el mallado a partir de un valor concreto de <math>h</math>.
<syntaxhighlight lang="MATLAB">
function [ntheta_inner, ntheta_outer, nr_inner, nr_outer] = calculate_con_mesh_params(h, R, r1)
%calcula los parámetros de generate_mesh necesarios para conseguir una
%cierta "h" (es un poco heurístico e impreciso, pero funciona!)
circum_inner = 2*pi*r1;
circum_outer = 2*pi*R;

%divisiones angulares
ntheta_inner = max(3, ceil(circum_inner / h));
ntheta_outer = max(3, ceil(circum_outer / h));

%divisiones de tipo anillo
nr_inner = max(1, ceil(r1 / h));
nr_outer = max(1, ceil((R - r1) / h));
end

</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h</math> concreta y una "excentricidad" dada.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
Este código representa el mallado que hemos generado con las funciones anteriores, diferenciando en las dos regiones <math>\Omega_1</math> y <math>\Omega_2</math>.
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
Este código representa la solución que calculan los códigos posteriores.
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
Este código ensambla el sistema lineal que resulta del método de elementos finitos.
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
La función principal, aplica las funciones anteriores a un problema concreto, generando el mallado y usándolo con una <math>f</math> concreta, definida en el mismo código.
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T21:55:19Z

Nacho:

{{ TrabajoED | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=

[Archivo:Poster MNEDP 2025 CAD.jpg]

También es posible [https://objectstorage.eu-madrid-3.oraclecloud.com/n/axfzuuzt6hgr/b/bucket-20251109-1118/o/Poster_MNEDP_2025_CAD.pdf ver el póster en PDF a resolución completa].

=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: calculate_con_mesh_params.m ==
Este código se encarga de escoger unos parámetros concretos para el mallado a partir de un valor concreto de <math>h</math>.
<syntaxhighlight lang="MATLAB">
function [ntheta_inner, ntheta_outer, nr_inner, nr_outer] = calculate_con_mesh_params(h, R, r1)
%calcula los parámetros de generate_mesh necesarios para conseguir una
%cierta "h" (es un poco heurístico e impreciso, pero funciona!)
circum_inner = 2*pi*r1;
circum_outer = 2*pi*R;

%divisiones angulares
ntheta_inner = max(3, ceil(circum_inner / h));
ntheta_outer = max(3, ceil(circum_outer / h));

%divisiones de tipo anillo
nr_inner = max(1, ceil(r1 / h));
nr_outer = max(1, ceil((R - r1) / h));
end

</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h</math> concreta y una "excentricidad" dada.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
Este código representa el mallado que hemos generado con las funciones anteriores, diferenciando en las dos regiones <math>\Omega_1</math> y <math>\Omega_2</math>.
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
Este código representa la solución que calculan los códigos posteriores.
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
Este código ensambla el sistema lineal que resulta del método de elementos finitos.
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
La función principal, aplica las funciones anteriores a un problema concreto, generando el mallado y usándolo con una <math>f</math> concreta, definida en el mismo código.
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Archivo:Poster MNEDP 2025 CAD.jpg

2025-11-16T21:53:37Z

Nacho: Póster del trabajo "Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN" de Métodos Numéricos en EDP impartida por Carlos Castro y Maria Luisa Rapún en el Grado en Matemáticas. Trabajo realizado por el grupo CAD. Curso 2025/2026.

Póster del trabajo "Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN" de Métodos Numéricos en EDP impartida por Carlos Castro y Maria Luisa Rapún en el Grado en Matemáticas. Trabajo realizado por el grupo CAD. Curso 2025/2026.

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T21:42:30Z

Nacho: /* Póster del Trabajo */

{{ TrabajoED | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=

=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: calculate_con_mesh_params.m ==
Este código se encarga de escoger unos parámetros concretos para el mallado a partir de un valor concreto de <math>h</math>.
<syntaxhighlight lang="MATLAB">
function [ntheta_inner, ntheta_outer, nr_inner, nr_outer] = calculate_con_mesh_params(h, R, r1)
%calcula los parámetros de generate_mesh necesarios para conseguir una
%cierta "h" (es un poco heurístico e impreciso, pero funciona!)
circum_inner = 2*pi*r1;
circum_outer = 2*pi*R;

%divisiones angulares
ntheta_inner = max(3, ceil(circum_inner / h));
ntheta_outer = max(3, ceil(circum_outer / h));

%divisiones de tipo anillo
nr_inner = max(1, ceil(r1 / h));
nr_outer = max(1, ceil((R - r1) / h));
end

</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h</math> concreta y una "excentricidad" dada.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
Este código representa el mallado que hemos generado con las funciones anteriores, diferenciando en las dos regiones <math>\Omega_1</math> y <math>\Omega_2</math>.
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
Este código representa la solución que calculan los códigos posteriores.
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
Este código ensambla el sistema lineal que resulta del método de elementos finitos.
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
La función principal, aplica las funciones anteriores a un problema concreto, generando el mallado y usándolo con una <math>f</math> concreta, definida en el mismo código.
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T21:41:26Z

Nacho: /* Póster del Trabajo */

{{ TrabajoED | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=
[https://objectstorage.eu-madrid-3.oraclecloud.com/n/axfzuuzt6hgr/b/bucket-20251109-1118/o/Poster_MNEDP.pdf Ver póster en PDF]

=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: calculate_con_mesh_params.m ==
Este código se encarga de escoger unos parámetros concretos para el mallado a partir de un valor concreto de <math>h</math>.
<syntaxhighlight lang="MATLAB">
function [ntheta_inner, ntheta_outer, nr_inner, nr_outer] = calculate_con_mesh_params(h, R, r1)
%calcula los parámetros de generate_mesh necesarios para conseguir una
%cierta "h" (es un poco heurístico e impreciso, pero funciona!)
circum_inner = 2*pi*r1;
circum_outer = 2*pi*R;

%divisiones angulares
ntheta_inner = max(3, ceil(circum_inner / h));
ntheta_outer = max(3, ceil(circum_outer / h));

%divisiones de tipo anillo
nr_inner = max(1, ceil(r1 / h));
nr_outer = max(1, ceil((R - r1) / h));
end

</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h</math> concreta y una "excentricidad" dada.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
Este código representa el mallado que hemos generado con las funciones anteriores, diferenciando en las dos regiones <math>\Omega_1</math> y <math>\Omega_2</math>.
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
Este código representa la solución que calculan los códigos posteriores.
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
Este código ensambla el sistema lineal que resulta del método de elementos finitos.
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
La función principal, aplica las funciones anteriores a un problema concreto, generando el mallado y usándolo con una <math>f</math> concreta, definida en el mismo código.
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T21:40:37Z

Nacho:

{{ TrabajoED | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=
<iframe
src="https://objectstorage.eu-madrid-3.oraclecloud.com/n/axfzuuzt6hgr/b/bucket-20251109-1118/o/Poster_MNEDP.pdf"
width="100%"
height="800px">
</iframe>
=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: calculate_con_mesh_params.m ==
Este código se encarga de escoger unos parámetros concretos para el mallado a partir de un valor concreto de <math>h</math>.
<syntaxhighlight lang="MATLAB">
function [ntheta_inner, ntheta_outer, nr_inner, nr_outer] = calculate_con_mesh_params(h, R, r1)
%calcula los parámetros de generate_mesh necesarios para conseguir una
%cierta "h" (es un poco heurístico e impreciso, pero funciona!)
circum_inner = 2*pi*r1;
circum_outer = 2*pi*R;

%divisiones angulares
ntheta_inner = max(3, ceil(circum_inner / h));
ntheta_outer = max(3, ceil(circum_outer / h));

%divisiones de tipo anillo
nr_inner = max(1, ceil(r1 / h));
nr_outer = max(1, ceil((R - r1) / h));
end

</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h</math> concreta y una "excentricidad" dada.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
Este código representa el mallado que hemos generado con las funciones anteriores, diferenciando en las dos regiones <math>\Omega_1</math> y <math>\Omega_2</math>.
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
Este código representa la solución que calculan los códigos posteriores.
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
Este código ensambla el sistema lineal que resulta del método de elementos finitos.
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
La función principal, aplica las funciones anteriores a un problema concreto, generando el mallado y usándolo con una <math>f</math> concreta, definida en el mismo código.
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T20:27:32Z

Nacho:

{{ TrabajoED | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=
Por ahora no está! (carita triste)
=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: calculate_con_mesh_params.m ==
Este código se encarga de escoger unos parámetros concretos para el mallado a partir de un valor concreto de <math>h</math>.
<syntaxhighlight lang="MATLAB">
function [ntheta_inner, ntheta_outer, nr_inner, nr_outer] = calculate_con_mesh_params(h, R, r1)
%calcula los parámetros de generate_mesh necesarios para conseguir una
%cierta "h" (es un poco heurístico e impreciso, pero funciona!)
circum_inner = 2*pi*r1;
circum_outer = 2*pi*R;

%divisiones angulares
ntheta_inner = max(3, ceil(circum_inner / h));
ntheta_outer = max(3, ceil(circum_outer / h));

%divisiones de tipo anillo
nr_inner = max(1, ceil(r1 / h));
nr_outer = max(1, ceil((R - r1) / h));
end

</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h</math> concreta y una "excentricidad" dada.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
Este código representa el mallado que hemos generado con las funciones anteriores, diferenciando en las dos regiones <math>\Omega_1</math> y <math>\Omega_2</math>.
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
Este código representa la solución que calculan los códigos posteriores.
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
Este código ensambla el sistema lineal que resulta del método de elementos finitos.
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
La función principal, aplica las funciones anteriores a un problema concreto, generando el mallado y usándolo con una <math>f</math> concreta, definida en el mismo código.
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T20:25:53Z

Nacho:

{{ TrabajoMNEDP | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=
Por ahora no está! (carita triste)
=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: calculate_con_mesh_params.m ==
Este código se encarga de escoger unos parámetros concretos para el mallado a partir de un valor concreto de <math>h</math>.
<syntaxhighlight lang="MATLAB">
function [ntheta_inner, ntheta_outer, nr_inner, nr_outer] = calculate_con_mesh_params(h, R, r1)
%calcula los parámetros de generate_mesh necesarios para conseguir una
%cierta "h" (es un poco heurístico e impreciso, pero funciona!)
circum_inner = 2*pi*r1;
circum_outer = 2*pi*R;

%divisiones angulares
ntheta_inner = max(3, ceil(circum_inner / h));
ntheta_outer = max(3, ceil(circum_outer / h));

%divisiones de tipo anillo
nr_inner = max(1, ceil(r1 / h));
nr_outer = max(1, ceil((R - r1) / h));
end

</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h</math> concreta y una "excentricidad" dada.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
Este código representa el mallado que hemos generado con las funciones anteriores, diferenciando en las dos regiones <math>\Omega_1</math> y <math>\Omega_2</math>.
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
Este código representa la solución que calculan los códigos posteriores.
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
Este código ensambla el sistema lineal que resulta del método de elementos finitos.
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
La función principal, aplica las funciones anteriores a un problema concreto, generando el mallado y usándolo con una <math>f</math> concreta, definida en el mismo código.
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T20:22:16Z

Nacho: /* Código: generate_mesh.m */

{{ TrabajoMNEDP | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=
Por ahora no está! (carita triste)
=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h</math> concreta y una "excentricidad" dada.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T20:21:55Z

Nacho: /* Código: generate_mesh.m */

{{ TrabajoMNEDP | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=
Por ahora no está! (carita triste)
=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h</math> concreta.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T20:21:19Z

Nacho: /* Código: generate_mesh.m */

{{ TrabajoMNEDP | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=
Por ahora no está! (carita triste)
=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: generate_mesh.m ==
Este código se encarga de generar el mallado para una <math>h<\math> concreta.
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T20:20:11Z

Nacho: /* Código: make_concentric_mesh.m */

{{ TrabajoMNEDP | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=
Por ahora no está! (carita triste)
=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
Esta función se encarga de generar el mallado.
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: generate_mesh.m ==
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T20:17:19Z

Nacho:

{{ TrabajoMNEDP | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Claudia Domínguez, Ignacio Martínez, Analía Olivero}}

=Póster del Trabajo=
Por ahora no está! (carita triste)
=Códigos de MatLab=
== Código: make_concentric_mesh.m ==
<syntaxhighlight lang="MATLAB">
function [points, cells, regions] = make_concentric_mesh( ...
R, r1, ntheta_outer, ntheta_inner, nr_inner, nr_outer, exc, save_path)

%esta función genera el mallado de la elipse añadiendo radios y elipses
%semejantes más pequeñas interiores (anillos elípticos)

% exc = semieje vertical / semieje horizontal

% radios
r_inner = linspace(0, r1, nr_inner + 1);
r_outer = linspace(r1, R, nr_outer + 1);
radii = [r_inner, r_outer(2:end)];
k_if = nr_inner; % índice de la circunferencia interfaz
n_rings = numel(radii);

% listas para guardar los datos
points = [];
%como diferentes anillos tienen diferentes tamaños (los exteriores y
%los interiores) no nos vale con un vector/array, así que usamos celdas
% (más parecido a una lista de Python)
ring_nodes = cell(1, n_rings);
%esto genera una secuencia de celdas 1xn_rings, que contendrá los
%índices de los nodos de nuestros anillos

% k = 0 es el centro (origen)
points = [0 0];
ring_nodes{1} = 1;

%ángulos
thetas_outer = linspace(0, 2*pi, ntheta_outer+1);
thetas_outer(end) = [];
thetas_inner = linspace(0, 2*pi, ntheta_inner+1);
thetas_inner(end) = [];

% anillos interiores
for k = 2:k_if
r = radii(k);
x = r * cos(thetas_inner);
% escalado vertical (exc)
y = exc * r * sin(thetas_inner);

%guaradamos los puntos y los nodos de este anillo
start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_inner - 1);
end

% anillos exteriores
for k = k_if+1:n_rings
r = radii(k);
x = r * cos(thetas_outer);
%escalado horizontal
y = exc * r * sin(thetas_outer);

start_idx = size(points,1) + 1;
pts = [x(:), y(:)];
points = [points; pts];
ring_nodes{k} = start_idx : (start_idx + ntheta_outer - 1);
end

% triangulación: recorremos los anillos, que tienen el mismo número de
% puntos cada uno, tomando dos nodos del anillo interior y sus dos
% corrrespondientes del anillo esterior, formamos un cuadrilátero y lo
% dividimos en dos, lo que genera una triangulación.
cells = [];
regions = [];

% 1. "estrella" interior (emanan del origen)
for j = 1:ntheta_inner
a = ring_nodes{1}(1);
b = ring_nodes{2}(j);
c = ring_nodes{2}(mod(j,ntheta_inner)+1);

cells(end+1,:) = [a, b, c];
regions(end+1) = 1;
end

% triangulación de Omega_1 (menos el centro) - anillos interiores,
% Omega_1
for k = 2:k_if

inner = ring_nodes{k}; %anillo interior (de Omega_1)
outer = ring_nodes{k+1}; %anillo exterior (de Omega_1)
N = ntheta_inner; %número de nodos en cada anillo

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); % el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo
regions(end+1) = 1; %marcamos este triángulo como uno de Omega_1

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 1;%lo marcamos como de Omega_1
end
end

% triangulación de Omega_2
for k = k_if+1:n_rings-1
inner = ring_nodes{k}; %anillo interior de Omega_2
outer = ring_nodes{k+1}; %anillo exterior de Omega_2
N = ntheta_outer; %número de nodos

for j = 1:N
a = inner(j); %un nodo interior
b = inner(mod(j,N)+1); %el siguiente nodo interior
c = outer(j); %un nodo exterior
d = outer(mod(j,N)+1); %el siguiente nodo exterior

cells(end+1,:) = [a b d]; %primer triángulo del cuadrilátero
regions(end+1) = 2;%lo marcamos como de Omega_2

cells(end+1,:) = [a d c]; %segundo triángulo
regions(end+1) = 2;%lo marcamos como de Omega_2
end
end

% lo guardamos
save(save_path, "points", "cells", "regions");

end
</syntaxhighlight>

== Código: generate_mesh.m ==
<syntaxhighlight lang="MATLAB">

function generate_mesh(h, name, exc)
%calculamos los valores que nos dan esta h mínima
[ntheta_inner, ntheta_outer, nr_inner, nr_outer] = ...
calculate_con_mesh_params(h, 1.0, 0.95);

ntheta_outer = max([3, ntheta_inner, ntheta_outer]);
ntheta_inner = ntheta_outer;

%generamos el mallado (y se guarda)
make_concentric_mesh( ...
1.0, 0.95, ntheta_outer, ntheta_inner, nr_inner, nr_outer, ...
exc, name + ".mat");
end
</syntaxhighlight>

== Código: plot_mesh.m ==
<syntaxhighlight lang="MATLAB">
function plot_mesh(mesh, h)
%representación del mallado en dos partes Omega_1 y Omega_2

%cargamos cada parte del mallado
T = mesh.cells;
P = mesh.points;
R = mesh.regions;

% Índices de triángulos de cada región
idx1 = (R == 1);
idx2 = (R == 2);

figure('Position',[100 100 900 700]); hold on;

%hacemos un triplot de los triángulos de Omega_1 (a un color)
triplot(T(idx1,:), P(:,1), P(:,2), color = '#80B3FF');
%hacemos otro triplot de los triángulos de Omega_2 (a otro color)
triplot(T(idx2,:), P(:,1), P(:,2), 'blue');

title("Representación del mallado por regiones");
xlabel('X');
ylabel('Y');
axis equal;
saveas(gcf, "mesh_representation h="+num2str(h)+".pdf");
hold off;
end
</syntaxhighlight>

== Código: plot_solution.m ==
<syntaxhighlight lang="MATLAB">
function plot_solution(P, T, u, elev, azim, levels, prefijo)

%Representamos la superficie
figure('Name','Rerepsetnación como superficie');
%hacemos un trisurf sin marcar los triángulos (queda feo si hay muchos)
trisurf(T, P(:,1), P(:,2), u, 'EdgeColor','none');
xlabel('x'); ylabel('y'); zlabel('u');
%los parámetros de vista iniciales son parámetros
view(elev, azim);
axis equal; axis tight;
colorbar;
title('Solución FEM (superficie 3D)');

%lo guardamos
saveas(gcf, prefijo + "_surface.png");

%otra figura para el mapa de calor de los niveles
figure('Name','Representación como contorno');

%como no podemos hacerlo circular (no sabemos), lo hacemos cuadrado
xg = linspace(min(P(:,1)), max(P(:,1)), 300);
yg = linspace(min(P(:,2)), max(P(:,2)), 300);

[X,Y] = meshgrid(xg, yg);

%función para interpolar los datos de los nodos al resto del mallado
Fint = scatteredInterpolant(P(:,1), P(:,2), u, 'natural');
Ugrid = Fint(X,Y);

%contornos (sin líneas en los bordes)
contourf(X, Y, Ugrid, levels, 'LineColor','none');

axis equal; axis tight;
xlabel('x'); ylabel('y');
colormap('jet');
colorbar;
title('Solución FEM (contorno)');
%lo guardamos
saveas(gcf, prefijo + "_contour.png");

end

</syntaxhighlight>

== Código: assemble_system.m ==
<syntaxhighlight lang="MATLAB">
function [A, F, P, T] = assemble_system(mesh_path, f_rhs)

data = load(mesh_path, "points", "cells", "regions");
P = data.points; % Nx2
T = data.cells; % Mx3
R = data.regions; % Mx1 (región de cada elemento)

N = size(P, 1);
M = size(T, 1);

%conductividades
sigma1 = 0.33; % cerebro
sigma2 = 0.16; % cráneo

%matriz global y vector de cargas
A = sparse(N, N);
F = zeros(N, 1);

%bucle sobre elementos
for k = 1:M
nodes = T(k, :); %índices de los nodos del triángulo, 1x3
coords = P(nodes, :); %coordenada, 3x2

x1 = coords(1,1);
y1 = coords(1,2);

x2 = coords(2,1);
y2 = coords(2,2);

x3 = coords(3,1);
y3 = coords(3,2);

area = 0.5 * abs( (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1) );

% Escogemos sigma según región
if R(k) == 1
sigma = sigma1;
else
sigma = sigma2;
end

%matriz BK (igual que en clase)
BK = [coords(2,1) - coords(1,1), coords(3,1) - coords(1,1);
coords(2,2) - coords(1,2), coords(3,2) - coords(1,2)];

%matriz de rigidez local (igual que en clase, pero en otra función
%para que sea más limpio)
Ke = local_stiffness_L(2*area, BK, sigma);

%calculamos la aportación al vector de cargas diferenciando entre
%la región interior y la región exterior
if R(k) == 1
%hacemos la media de la f, igual que en clase
fk = 1/3 * (f_rhs(x1,y1) + f_rhs(x2,y2)+ f_rhs(x3,y3));
fe = local_load_L(BK, fk);
else
fe = zeros(3, 1);
end

% Añadimos las aportaciones al vector de carga y a la matriz de
% rigidez de este triángulo
F(nodes) = F(nodes) + fe;
A(nodes, nodes) = A(nodes, nodes) + Ke;
end
end

function Ke = local_stiffness_L(alpha, BK, sigma)
% Matriz de rigidez local
% Matriz de deformación Ck = inv(BK) @ inv(BK).T
invBk = inv(BK);

Ck = invBk*invBk';

% Matrices L
Lxx = 0.5 * [1, -1, 0; -1, 1, 0; 0, 0, 0];
Lyy = 0.5 * [1, 0, -1; 0, 0, 0; -1, 0, 1];
Lxy = 0.5 * [1, -1, 0; 0, 0, 0; -1, 1, 0];

% Matriz local de rigidez
LK = Ck(1,1)*Lxx + Ck(1,2)*(Lxy + Lxy') + Ck(2,2)*Lyy;
Ke = sigma * 0.5 * abs(alpha) * LK;
end

function fe = local_load_L(BK, fK)
%vector de carga local de 3x1 usando:
% fe = fK * |det(BK)| * ell0
%donde ell0 = [1/6; 1/6; 1/6] (apuntes)

ell0 = [1/6; 1/6; 1/6];
area2 = abs(det(BK)); % |det(BK)| = 2 * area
fe = fK * area2 * ell0;
end

</syntaxhighlight>

== Código: main.m ==
<syntaxhighlight lang="MATLAB">
%escogemos una h y un valor de "excentricidad"
h = 0.025;
%esta "excentricidad" no es rigurosa, es simplemente un parámetro para
%regular cómo de achatada es la elipse de nuestra región, ¡no todas las
%cabezas son iguales!
excentricidad = 1;

% generamos el mallado
mesh_name = "head_mesh";
generate_mesh(h, mesh_name, excentricidad)
mesh_path = mesh_name + ".mat";

%cargamos el mallado desde el archivo
mesh = load("head_mesh.mat", "points", "cells", "regions");

plot_mesh(mesh, h)

%parámetros para el doble dipolo
%intensidad del primer dipolo suave
A1 = 2;
%intensidad del segundo dipolo suave
A2 = -2;
%"radio" inverso del dipolo
TD = 0.02;

%definimos la función f
function val = f_rhslack(x, y, A1, A2, TD)
% % Fuente intracraneal f(x,y).
% val = x.^2 - y.^2 ;

x0 = 0; y0 = 0;
val = A1 * (x./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
% x0 = -0.1; y0 = -0.1;
% val = val + A2 * (y./ TD).*exp(-((x-x0).^2 + (y-y0).^2) / TD);
end
%handle de función con los valores de A1, A2 y TD definidos arriba
f_rhs = @(x,y) f_rhslack(x,y, A1, A2, TD);

%ensamblamos el sistema
[A, F, P, T] = assemble_system(mesh_path, f_rhs);

% Resolución del sistema
u = A \ F;

name = "SolucionFEMcabeza";

%Representación de la solución
plot_solution(P, T, u, 35, -60, 30, name)

</syntaxhighlight>

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T20:15:26Z

Nacho: /* Código: make_concentric_mesh.m */

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T20:15:05Z

Nacho: Añado la primera función a ver si se ve bien

Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN

2025-11-16T20:10:00Z

Nacho: Página creada con «{{ TrabajoMNEDP | Distribución del Potencial Eléctrico Cerebral (Modelo 2D) - CAN | MNEDP|2025-26 | Claudia Domínguez, I...»

Ecuación de Laplace y de Poisson (ILA)

2025-04-20T19:58:58Z

Nacho:

{{ TrabajoED | Ecuación de Laplace y de Poisson (Grupo ILA). | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] |
*Alicia Ruiz,
*Luis Ramos
*Ignacio Martínez
.}}

[[Categoría:EDP]]
[[Categoría:EDP24/25]]

Ecuación de Laplace y de Poisson (ILA)

2025-04-20T19:58:36Z

Nacho:

{{ TrabajoED | Ecuación de Laplace y de Poisson (Grupo ILA). | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] |
*Alicia Ruiz,
*Ignacio Martínez,
*todos.}}

[[Categoría:EDP]]
[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-20T07:31:37Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo ILIA | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

*'''Ecuación del calor sin fuente térmica:''' resolvemos el problema con condiciones iniciales y de frontera, y obtenemos la solución estacionaria.

*'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

*'''Comparación entre ambas:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\operatorname{sen}(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\operatorname{sen}(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
En los casos sencillos de la ecuación del calor, como los vistos en clase, no existe aporte de calor a nuestro sistema o, si existe, es regular a lo largo del espacio y el tiempo. Sin embargo, en muchas situaciones prácticas, el calor puede ser generado en puntos específicos del dominio. Para modelar este efecto, introducimos una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto concreto <math>x_0</math> de la barra de manera localizada. Así, la ecuación del calor modificada queda como sigue:

<center><math>u_t = u_{xx}+f(x,t)</math></center>

donde <math>f(x,t)</math> es una fuente térmica localizada, que modelamos como:

<center><math>f(x,t)=q(t)\delta(x-x_0)</math></center>

Aquí, <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac, que hace que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Para ilustrar este fenómeno, consideramos el mismo problema de la sección 2 pero con la fuente térmica puntual en <math>x_0=0.5</math>, con una intensidad constante <math>q(t)=2</math>. Obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

Si intentamos resolver este problema suponiendo la existencia de una solución estacionaria, debemos realizar la suposición de que la integral de la función <math>\delta</math> es la función Heaviside, es decir:
<center>
<math>
H(x) =
\begin{cases}
0 & x <0\\
1 & x \geq 0
\end{cases}
</math>
</center>
Con esta información:
<center>
<math>
\begin{align*}
-u_{xx}(x) &= 2\delta(x-0.5)\\
\Rightarrow -u_x(x) &= 2\int \delta(x-0.5)dx = 2H(x-0.5) + 2C_1= \begin{cases}
2C_1 &\text{ si } x< 0.5\\
2+2C_1 & \text{ si } x \geq 0.5
\end{cases}\\
\Rightarrow -u(x) &= 2\int H(x-0.5)dx + 2C_1\cdot x\\
\Rightarrow -u(x) & = 2\cdot\left((x-0.5)H(x-0.5) + C_2 + C_1\cdot x\right)\\
\end{align*}
</math>
</center>
Evaluando en las condiciones iniciales, llegamos a:
<center>
<math>
\begin{align*}
0 &= -u(0) = (-0.5)H(-0.5) + C_2\\
0&= 0 + C_2 \\
\Rightarrow C_2 &= 0
\end{align*}
</math>
</center>

<center>
<math>
\begin{align*}
0 &= -u(1) = (0.5)H(0.5) + C_1+ C_2\\
0&= 0.5 + C_1\\
\Rightarrow C_1 &= -0.5
\end{align*}
</math>
</center>

Luego nuestra solución tendría la forma:
<center>
<math>
u(x) = 2 \left(-\left(\frac{2x-1}{2}\right)H\left(\frac{2x-1}{2}\right) +\frac{x}{2}\right)
</math>
</center>
Representando nuestra solución estacionaria, llegamos a:

[[Archivo:Solución estacionaria ILIA 2025 8K.png|400px|thumb|right|Solución de la ecuación del calor]]

Por la forma de nuestra ecuación cabría esperar una solución que, además de las condiciones iniciales, tenga (y a simple vista se aprecie) una zona de temperatura máxima en <math> x_0 = 0.5 </math>, donde a ambos lados la temperatura descendería hasta llegar a los extremos, donde la temperatura es constantemente nula.

Vista la solución estacionaria y vista que coincide con la hallada numéricamente, sin embargo, resulta algo difícil operar con estas funciones para hallar la solución homogeneizada, con lo que habitualmente se emplean formas alternativas de resolver el problema que involucran expresar la <math>\delta</math> como una combinación de las funciones de nuestra base de Fourier.

[[Archivo:EvolucionILIA.jpeg|400px|thumb|right|Evolución temporal de la ecuación del calor con fuente térmica]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numba

# Parámetros del problema
L = 1.0 # Longitud del dominio espacial
t0 = 0 #Tiempo inicial
T = 0.1 # Tiempo final
nx = 100 # Número de puntos en la dirección x
nt = 10000 # Número de pasos de tiempo
dx = L / (nx - 1) # diferencia en espacio
dt = (T-t0) / nt # diferencia en tiempo
alpha = 1.0 # Coeficiente de difusión (para la ecuación del calor)
r = alpha * dt / (dx**2) #Coeficiente de estabilidad

# Verificamos que se cumple la cond. de estabilidad para el esquema
if r > 0.5:
raise ValueError(f"La condición de estabilidad no se cumple, 0.5 < {r=}")

#Inicializamos el intervalo discretizado en x
x = np.linspace(0, L, nx)

#Inicializamos el intervalo en t que vamos a emplear
t = np.linspace(t0, T, nt + 1)

#Creamos el mallado en x y t:
X,T_mesh = np.meshgrid(x,t)

# Inicializar la solución u(x, t) con ceros
u = np.zeros((nt + 1, nx))

# Aplicamos las condiciones de frontera e inicial
u[:, 0] = 0
u[:, -1] = 0
u[0, :] = np.sin(2*np.pi*x)

# Calculamos el índice del punto más cercano a x = 0.5
index_source = int(0.5 / dx)

# Evolución temporal
for n in range(nt):
u[n + 1, :] = u[n, :] # Inicializar la siguiente iteración con los valores actuales
for i in range(1, nx - 1):
u[n + 1, i] = u[n, i] + r * (u[n, i + 1] - 2 * u[n, i] + u[n, i - 1])
# Aproximación de la delta de Dirac
u[n + 1, index_source] += 2 * dt / dx

# Crear la figura y el subplot 3D
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficar la superficie, y añadimos etiquetas, barra de color, etc.
surf = ax.plot_surface(X, T_mesh, u, cmap='viridis')
ax.set_xlabel('x')
ax.set_ylabel('t')
ax.set_zlabel('u(x, t)')
ax.set_title('Evolución temporal de la ecuación de calor con fuente (aproximación numérica)')
fig.colorbar(surf, ax=ax, label='u(x, t)')

plt.show()
</syntaxhighlight>

===Interpretación de la solución numérica y comparación con el caso sin fuente===
Los resultados numéricos muestran que efectivamente la fuente térmica localizada en <math> x_0 = 0.5 </math> genera una acumulación de calor en su entorno inmediato. A medida que avanza el tiempo, se observa la disipación progresiva del calor debido a la difusión, que suaviza la temperatura alrededor de este punto, extendiéndola hacia el resto del dominio.

En comparación con el caso sin fuente, donde la temperatura inicial se disipa homogéneamente y tiende a cero en todo el dominio, en este caso se observa un comportamiento diferente: la región en torno a <math> x_0 = 0.5 </math> se mantiene significativamente más caliente durante más tiempo. Esto refleja el efecto de la fuente térmica puntual, que introduce energía de manera continua en el sistema, impidiendo que la temperatura disminuya de forma uniforme.

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-20T07:31:09Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo ILIA | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

*'''Ecuación del calor sin fuente térmica:''' resolvemos el problema con condiciones iniciales y de frontera, y obtenemos la solución estacionaria.

*'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

*'''Comparación entre ambas:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\operatorname{sen}(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\operatorname{sen}(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
En los casos sencillos de la ecuación del calor, como los vistos en clase, no existe aporte de calor a nuestro sistema o, si existe, es regular a lo largo del espacio y el tiempo. Sin embargo, en muchas situaciones prácticas, el calor puede ser generado en puntos específicos del dominio. Para modelar este efecto, introducimos una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto concreto <math>x_0</math> de la barra de manera localizada. Así, la ecuación del calor modificada queda como sigue:

<center><math>u_t = u_{xx}+f(x,t)</math></center>

donde <math>f(x,t)</math> es una fuente térmica localizada, que modelamos como:

<center><math>f(x,t)=q(t)\delta(x-x_0)</math></center>

Aquí, <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac, que hace que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Para ilustrar este fenómeno, consideramos el mismo problema de la sección 2 pero con la fuente térmica puntual en <math>x_0=0.5</math>, con una intensidad constante <math>q(t)=2</math>. Obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

Si intentamos resolver este problema suponiendo la existencia de una solución estacionaria, debemos realizar la suposición de que la integral de la función <math>\delta</math> es la función Heaviside, es decir:
<center>
<math>
H(x) =
\begin{cases}
0 & x <0\\
1 & x \geq 0
\end{cases}
</math>
</center>
Con esta información:
<center>
<math>
\begin{align*}
-u_{xx}(x) &= 2\delta(x-0.5)\\
\Rightarrow -u_x(x) &= 2\int \delta(x-0.5)dx = 2H(x-0.5) + 2C_1= \begin{cases}
2C_1 &\text{ si } x< 0.5\\
2+2C_1 & \text{ si } x \geq 0.5
\end{cases}\\
\Rightarrow -u(x) &= 2\int H(x-0.5)dx + 2C_1\cdot x\\
\Rightarrow -u(x) & = 2\cdot\left((x-0.5)H(x-0.5) + C_2 + C_1\cdot x\right)\\
\end{align*}
</math>
</center>
Evaluando en las condiciones iniciales, llegamos a:
<center>
<math>
\begin{align*}
0 &= -u(0) = (-0.5)H(-0.5) + C_2\\
0&= 0 + C_2 \\
\Rightarrow C_2 &= 0
\end{align*}
</math>
</center>

<center>
<math>
\begin{align*}
0 &= -u(1) = (0.5)H(0.5) + C_1+ C_2\\
0&= 0.5 + C_1\\
\Rightarrow C_1 &= -0.5
\end{align*}
</math>
</center>

Luego nuestra solución tendría la forma:
<center>
<math>
u(x) = 2 \left(-\frac{2x-1}{2}H\left(\frac{2x-1}{2}\right) +\frac{x}{2}\right)
</math>
</center>
Representando nuestra solución estacionaria, llegamos a:

[[Archivo:Solución estacionaria ILIA 2025 8K.png|400px|thumb|right|Solución de la ecuación del calor]]

Por la forma de nuestra ecuación cabría esperar una solución que, además de las condiciones iniciales, tenga (y a simple vista se aprecie) una zona de temperatura máxima en <math> x_0 = 0.5 </math>, donde a ambos lados la temperatura descendería hasta llegar a los extremos, donde la temperatura es constantemente nula.

Vista la solución estacionaria y vista que coincide con la hallada numéricamente, sin embargo, resulta algo difícil operar con estas funciones para hallar la solución homogeneizada, con lo que habitualmente se emplean formas alternativas de resolver el problema que involucran expresar la <math>\delta</math> como una combinación de las funciones de nuestra base de Fourier.

[[Archivo:EvolucionILIA.jpeg|400px|thumb|right|Evolución temporal de la ecuación del calor con fuente térmica]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numba

# Parámetros del problema
L = 1.0 # Longitud del dominio espacial
t0 = 0 #Tiempo inicial
T = 0.1 # Tiempo final
nx = 100 # Número de puntos en la dirección x
nt = 10000 # Número de pasos de tiempo
dx = L / (nx - 1) # diferencia en espacio
dt = (T-t0) / nt # diferencia en tiempo
alpha = 1.0 # Coeficiente de difusión (para la ecuación del calor)
r = alpha * dt / (dx**2) #Coeficiente de estabilidad

# Verificamos que se cumple la cond. de estabilidad para el esquema
if r > 0.5:
raise ValueError(f"La condición de estabilidad no se cumple, 0.5 < {r=}")

#Inicializamos el intervalo discretizado en x
x = np.linspace(0, L, nx)

#Inicializamos el intervalo en t que vamos a emplear
t = np.linspace(t0, T, nt + 1)

#Creamos el mallado en x y t:
X,T_mesh = np.meshgrid(x,t)

# Inicializar la solución u(x, t) con ceros
u = np.zeros((nt + 1, nx))

# Aplicamos las condiciones de frontera e inicial
u[:, 0] = 0
u[:, -1] = 0
u[0, :] = np.sin(2*np.pi*x)

# Calculamos el índice del punto más cercano a x = 0.5
index_source = int(0.5 / dx)

# Evolución temporal
for n in range(nt):
u[n + 1, :] = u[n, :] # Inicializar la siguiente iteración con los valores actuales
for i in range(1, nx - 1):
u[n + 1, i] = u[n, i] + r * (u[n, i + 1] - 2 * u[n, i] + u[n, i - 1])
# Aproximación de la delta de Dirac
u[n + 1, index_source] += 2 * dt / dx

# Crear la figura y el subplot 3D
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficar la superficie, y añadimos etiquetas, barra de color, etc.
surf = ax.plot_surface(X, T_mesh, u, cmap='viridis')
ax.set_xlabel('x')
ax.set_ylabel('t')
ax.set_zlabel('u(x, t)')
ax.set_title('Evolución temporal de la ecuación de calor con fuente (aproximación numérica)')
fig.colorbar(surf, ax=ax, label='u(x, t)')

plt.show()
</syntaxhighlight>

===Interpretación de la solución numérica y comparación con el caso sin fuente===
Los resultados numéricos muestran que efectivamente la fuente térmica localizada en <math> x_0 = 0.5 </math> genera una acumulación de calor en su entorno inmediato. A medida que avanza el tiempo, se observa la disipación progresiva del calor debido a la difusión, que suaviza la temperatura alrededor de este punto, extendiéndola hacia el resto del dominio.

En comparación con el caso sin fuente, donde la temperatura inicial se disipa homogéneamente y tiende a cero en todo el dominio, en este caso se observa un comportamiento diferente: la región en torno a <math> x_0 = 0.5 </math> se mantiene significativamente más caliente durante más tiempo. Esto refleja el efecto de la fuente térmica puntual, que introduce energía de manera continua en el sistema, impidiendo que la temperatura disminuya de forma uniforme.

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-20T07:29:33Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo ILIA | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

*'''Ecuación del calor sin fuente térmica:''' resolvemos el problema con condiciones iniciales y de frontera, y obtenemos la solución estacionaria.

*'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

*'''Comparación entre ambas:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\operatorname{sen}(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\operatorname{sen}(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
En los casos sencillos de la ecuación del calor, como los vistos en clase, no existe aporte de calor a nuestro sistema o, si existe, es regular a lo largo del espacio y el tiempo. Sin embargo, en muchas situaciones prácticas, el calor puede ser generado en puntos específicos del dominio. Para modelar este efecto, introducimos una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto concreto <math>x_0</math> de la barra de manera localizada. Así, la ecuación del calor modificada queda como sigue:

<center><math>u_t = u_{xx}+f(x,t)</math></center>

donde <math>f(x,t)</math> es una fuente térmica localizada, que modelamos como:

<center><math>f(x,t)=q(t)\delta(x-x_0)</math></center>

Aquí, <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac, que hace que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Para ilustrar este fenómeno, consideramos el mismo problema de la sección 2 pero con la fuente térmica puntual en <math>x_0=0.5</math>, con una intensidad constante <math>q(t)=2</math>. Obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

Si intentamos resolver este problema suponiendo la existencia de una solución estacionaria, debemos realizar la suposición de que la integral de la función <math>\delta</math> es la función Heaviside, es decir:
<center>
<math>
H(x) =
\begin{cases}
0 & x <0\\
1 & x \geq 0
\end{cases}
</math>
</center>
Con esta información:
<center>
<math>
\begin{align*}
-u_{xx}(x) &= 2\delta(x-0.5)\\
\Rightarrow -u_x(x) &= 2\int \delta(x-0.5)dx = 2H(x-0.5) + 2C_1= \begin{cases}
2C_1 &\text{ si } x< 0.5\\
2+2C_1 & \text{ si } x \geq 0.5
\end{cases}\\
\Rightarrow -u(x) &= 2\int H(x-0.5)dx + 2C_1\cdot x\\
\Rightarrow -u(x) & = 2\cdot\left((x-0.5)H(x-0.5) + C_2 + C_1\cdot x\right)\\
\end{align*}
</math>
</center>
Evaluando en las condiciones iniciales, llegamos a:
<center>
<math>
\begin{align*}
0 &= -u(0) = (-0.5)H(-0.5) + C_2\\
0&= 0 + C_2 \\
\Rightarrow C_2 &= 0
\end{align*}
</math>
</center>

<center>
<math>
\begin{align*}
0 &= -u(1) = (0.5)H(0.5) + C_1+ C_2\\
0&= 0.5 + C_1\\
\Rightarrow C_1 &= -0.5
\end{align*}
</math>
</center>

Luego nuestra solución tendría la forma:
<center>
<math>
u(x) = 2 \left(-\frac{2x-1}{2}H\left(\frac{2x-1}{2}\right +\frac{x}{2}\right)
</math>
</center>
Representando nuestra solución estacionaria, llegamos a:

[[Archivo:Solución estacionaria ILIA 2025 8K.png|400px|thumb|right|Solución de la ecuación del calor]]

Por la forma de nuestra ecuación cabría esperar una solución que, además de las condiciones iniciales, tenga (y a simple vista se aprecie) una zona de temperatura máxima en <math> x_0 = 0.5 </math>, donde a ambos lados la temperatura descendería hasta llegar a los extremos, donde la temperatura es constantemente nula.

Vista la solución estacionaria y vista que coincide con la hallada numéricamente, sin embargo, resulta algo difícil operar con estas funciones para hallar la solución homogeneizada, con lo que habitualmente se emplean formas alternativas de resolver el problema que involucran expresar la <math>\delta</math> como una combinación de las funciones de nuestra base de Fourier.

[[Archivo:EvolucionILIA.jpeg|400px|thumb|right|Evolución temporal de la ecuación del calor con fuente térmica]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numba

# Parámetros del problema
L = 1.0 # Longitud del dominio espacial
t0 = 0 #Tiempo inicial
T = 0.1 # Tiempo final
nx = 100 # Número de puntos en la dirección x
nt = 10000 # Número de pasos de tiempo
dx = L / (nx - 1) # diferencia en espacio
dt = (T-t0) / nt # diferencia en tiempo
alpha = 1.0 # Coeficiente de difusión (para la ecuación del calor)
r = alpha * dt / (dx**2) #Coeficiente de estabilidad

# Verificamos que se cumple la cond. de estabilidad para el esquema
if r > 0.5:
raise ValueError(f"La condición de estabilidad no se cumple, 0.5 < {r=}")

#Inicializamos el intervalo discretizado en x
x = np.linspace(0, L, nx)

#Inicializamos el intervalo en t que vamos a emplear
t = np.linspace(t0, T, nt + 1)

#Creamos el mallado en x y t:
X,T_mesh = np.meshgrid(x,t)

# Inicializar la solución u(x, t) con ceros
u = np.zeros((nt + 1, nx))

# Aplicamos las condiciones de frontera e inicial
u[:, 0] = 0
u[:, -1] = 0
u[0, :] = np.sin(2*np.pi*x)

# Calculamos el índice del punto más cercano a x = 0.5
index_source = int(0.5 / dx)

# Evolución temporal
for n in range(nt):
u[n + 1, :] = u[n, :] # Inicializar la siguiente iteración con los valores actuales
for i in range(1, nx - 1):
u[n + 1, i] = u[n, i] + r * (u[n, i + 1] - 2 * u[n, i] + u[n, i - 1])
# Aproximación de la delta de Dirac
u[n + 1, index_source] += 2 * dt / dx

# Crear la figura y el subplot 3D
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficar la superficie, y añadimos etiquetas, barra de color, etc.
surf = ax.plot_surface(X, T_mesh, u, cmap='viridis')
ax.set_xlabel('x')
ax.set_ylabel('t')
ax.set_zlabel('u(x, t)')
ax.set_title('Evolución temporal de la ecuación de calor con fuente (aproximación numérica)')
fig.colorbar(surf, ax=ax, label='u(x, t)')

plt.show()
</syntaxhighlight>

===Interpretación de la solución numérica y comparación con el caso sin fuente===
Los resultados numéricos muestran que efectivamente la fuente térmica localizada en <math> x_0 = 0.5 </math> genera una acumulación de calor en su entorno inmediato. A medida que avanza el tiempo, se observa la disipación progresiva del calor debido a la difusión, que suaviza la temperatura alrededor de este punto, extendiéndola hacia el resto del dominio.

En comparación con el caso sin fuente, donde la temperatura inicial se disipa homogéneamente y tiende a cero en todo el dominio, en este caso se observa un comportamiento diferente: la región en torno a <math> x_0 = 0.5 </math> se mantiene significativamente más caliente durante más tiempo. Esto refleja el efecto de la fuente térmica puntual, que introduce energía de manera continua en el sistema, impidiendo que la temperatura disminuya de forma uniforme.

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-19T11:17:41Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo ILIA | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

*'''Ecuación del calor sin fuente térmica:''' resolvemos el problema con condiciones iniciales y de frontera, y obtenemos la solución estacionaria.

*'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

*'''Comparación entre ambas:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\operatorname{sen}(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\operatorname{sen}(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
En los casos sencillos de la ecuación del calor, como los vistos en clase, no existe aporte de calor a nuestro sistema o, si existe, es regular a lo largo del espacio y el tiempo. Sin embargo, en muchas situaciones prácticas, el calor puede ser generado en puntos específicos del dominio. Para modelar este efecto, introducimos una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto concreto <math>x_0</math> de la barra de manera localizada. Así, la ecuación del calor modificada queda como sigue:

<center><math>u_t = u_{xx}+f(x,t)</math></center>

donde <math>f(x,t)</math> es una fuente térmica localizada, que modelamos como:

<center><math>f(x,t)=q(t)\delta(x-x_0)</math></center>

Aquí, <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac, que hace que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Para ilustrar este fenómeno, consideramos el mismo problema de la sección 2 pero con la fuente térmica puntual en <math>x_0=0.5</math>, con una intensidad constante <math>q(t)=2</math>. Obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

Si intentamos resolver este problema suponiendo la existencia de una solución estacionaria, debemos realizar la suposición de que la integral de la función <math>\delta</math> es la función Heaviside, es decir:
<center>
<math>
H(x) =
\begin{cases}
0 & x <0\\
1 & x \geq 0
\end{cases}
</math>
</center>
Con esta información:
<center>
<math>
\begin{align*}
-u_{xx}(x) &= 2\delta(x-0.5)\\
\Rightarrow -u_x(x) &= 2\int \delta(x-0.5)dx = 2H(x-0.5) + 2C_1= \begin{cases}
2C_1 &\text{ si } x< 0.5\\
2+2C_1 & \text{ si } x \geq 0.5
\end{cases}\\
\Rightarrow -u(x) &= 2\int H(x-0.5)dx + 2C_1\cdot x\\
\Rightarrow -u(x) & = 2\cdot\left((x-0.5)H(x-0.5) + C_2 + C_1\cdot x\right)\\
\end{align*}
</math>
</center>
Evaluando en las condiciones iniciales, llegamos a:
<center>
<math>
\begin{align*}
0 &= -u(0) = (-0.5)H(-0.5) + C_2\\
0&= 0 + C_2 \\
\Rightarrow C_2 &= 0
\end{align*}
</math>
</center>

<center>
<math>
\begin{align*}
0 &= -u(1) = (0.5)H(0.5) + C_1+ C_2\\
0&= 0.5 + C_2\\
\Rightarrow C_2 &= -0.5
\end{align*}
</math>
</center>

Luego nuestra solución tendría la forma:
<center>
<math>
u(x) = 2\cdot\left(\left(\frac{2x-1}{2}\right)H\left(\frac{2x-1}{2}\right) + \frac{x}{2}\right)
</math>
</center>
Representando nuestra solución estacionaria, llegamos a:

[[Archivo:Solución estacionaria ILIA 2025 8K.png|400px|thumb|right|Solución de la ecuación del calor]]

Por la forma de nuestra ecuación cabría esperar una solución que, además de las condiciones iniciales, tenga (y a simple vista se aprecie) una zona de temperatura máxima en <math> x_0 = 0.5 </math>, donde a ambos lados la temperatura descendería hasta llegar a los extremos, donde la temperatura es constantemente nula.

Vista la solución estacionaria y vista que coincide con la hallada numéricamente, sin embargo, resulta algo difícil operar con estas funciones para hallar la solución homogeneizada, con lo que habitualmente se emplean formas alternativas de resolver el problema que involucran expresar la <math>\delta</math> como una combinación de las funciones de nuestra base de Fourier.

[[Archivo:EvolucionILIA.jpeg|400px|thumb|right|Evolución temporal de la ecuación del calor con fuente térmica]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numba

# Parámetros del problema
L = 1.0 # Longitud del dominio espacial
t0 = 0 #Tiempo inicial
T = 0.1 # Tiempo final
nx = 100 # Número de puntos en la dirección x
nt = 10000 # Número de pasos de tiempo
dx = L / (nx - 1) # diferencia en espacio
dt = (T-t0) / nt # diferencia en tiempo
alpha = 1.0 # Coeficiente de difusión (para la ecuación del calor)
r = alpha * dt / (dx**2) #Coeficiente de estabilidad

# Verificamos que se cumple la cond. de estabilidad para el esquema
if r > 0.5:
raise ValueError(f"La condición de estabilidad no se cumple, 0.5 < {r=}")

#Inicializamos el intervalo discretizado en x
x = np.linspace(0, L, nx)

#Inicializamos el intervalo en t que vamos a emplear
t = np.linspace(t0, T, nt + 1)

#Creamos el mallado en x y t:
X,T_mesh = np.meshgrid(x,t)

# Inicializar la solución u(x, t) con ceros
u = np.zeros((nt + 1, nx))

# Aplicamos las condiciones de frontera e inicial
u[:, 0] = 0
u[:, -1] = 0
u[0, :] = np.sin(2*np.pi*x)

# Calculamos el índice del punto más cercano a x = 0.5
index_source = int(0.5 / dx)

# Evolución temporal
for n in range(nt):
u[n + 1, :] = u[n, :] # Inicializar la siguiente iteración con los valores actuales
for i in range(1, nx - 1):
u[n + 1, i] = u[n, i] + r * (u[n, i + 1] - 2 * u[n, i] + u[n, i - 1])
# Aproximación de la delta de Dirac
u[n + 1, index_source] += 2 * dt / dx

# Crear la figura y el subplot 3D
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficar la superficie, y añadimos etiquetas, barra de color, etc.
surf = ax.plot_surface(X, T_mesh, u, cmap='viridis')
ax.set_xlabel('x')
ax.set_ylabel('t')
ax.set_zlabel('u(x, t)')
ax.set_title('Evolución temporal de la ecuación de calor con fuente (aproximación numérica)')
fig.colorbar(surf, ax=ax, label='u(x, t)')

plt.show()
</syntaxhighlight>

===Interpretación de la solución numérica y comparación con el caso sin fuente===
Los resultados numéricos muestran que efectivamente la fuente térmica localizada en <math> x_0 = 0.5 </math> genera una acumulación de calor en su entorno inmediato. A medida que avanza el tiempo, se observa la disipación progresiva del calor debido a la difusión, que suaviza la temperatura alrededor de este punto, extendiéndola hacia el resto del dominio.

En comparación con el caso sin fuente, donde la temperatura inicial se disipa homogéneamente y tiende a cero en todo el dominio, en este caso se observa un comportamiento diferente: la región en torno a <math> x_0 = 0.5 </math> se mantiene significativamente más caliente durante más tiempo. Esto refleja el efecto de la fuente térmica puntual, que introduce energía de manera continua en el sistema, impidiendo que la temperatura disminuya de forma uniforme.

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-19T11:14:51Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo ILIA | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

*'''Ecuación del calor sin fuente térmica:''' resolvemos el problema con condiciones iniciales y de frontera, y obtenemos la solución estacionaria.

*'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

*'''Comparación entre ambas:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\operatorname{sen}(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\operatorname{sen}(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
En los casos sencillos de la ecuación del calor, como los vistos en clase, no existe aporte de calor a nuestro sistema o, si existe, es regular a lo largo del espacio y el tiempo. Sin embargo, en muchas situaciones prácticas, el calor puede ser generado en puntos específicos del dominio. Para modelar este efecto, introducimos una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto concreto <math>x_0</math> de la barra de manera localizada. Así, la ecuación del calor modificada queda como sigue:

<center><math>u_t = u_{xx}+f(x,t)</math></center>

donde <math>f(x,t)</math> es una fuente térmica localizada, que modelamos como:

<center><math>f(x,t)=q(t)\delta(x-x_0)</math></center>

Aquí, <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac, que hace que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Para ilustrar este fenómeno, consideramos el mismo problema de la sección 2 pero con la fuente térmica puntual en <math>x_0=0.5</math>, con una intensidad constante <math>q(t)=2</math>. Obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

Si intentamos resolver este problema suponiendo la existencia de una solución estacionaria, debemos realizar la suposición de que la integral de la función <math>\delta</math> es la función Heaviside, es decir:
<center>
<math>
H(x) =
\begin{cases}
0 & x <0\\
1 & x \geq 0
\end{cases}
</math>
</center>
Con esta información:
<math>
\begin{align*}
-u_{xx}(x) &= 2\delta(x-0.5)\\
\Rightarrow -u_x(x) &= 2\int \delta(x-0.5)dx = 2H(x-0.5) + 2C_1= \begin{cases}
2C_1 &\text{ si } x< 0.5\\
2+2C_1 & \text{ si } x \geq 0.5
\end{cases}\\
\Rightarrow -u(x) &= 2\int H(x-0.5)dx + 2C_1\cdot x\\
\Rightarrow -u(x) & = 2\cdot\left((x-0.5)H(x-0.5) + C_2 + C_1\cdot x\right)\\
\end{align*}
</math>
Evaluando en las condiciones iniciales, llegamos a:
<math>
\begin{align*}
0 &= -u(0) = (-0.5)H(-0.5) + C_2\\
0&= 0 + C_2 \Rightarrow C_2 = 0
\end{align*}
</math>
<math>
\begin{align*}
0 &= -u(1) = (0.5)H(0.5) + C_1+ C_2\\
0&= 0.5 + C_2\\
\Rightarrow C_2 &= -0.5
\end{align*}
</math>
Luego nuestra solución tendría la forma:
<center>
<math>
u(x) = 2\cdot\left(\left(\frac{2x-1}{2}\right)H\left(\frac{2x-1}{2}\right) + \frac{x}{2}\right)
</math>
</center>
Representando nuestra solución estacionaria, llegamos a:

[[Archivo:Solución estacionaria ILIA 2025 8K.png|400px|thumb|right|Solución de la ecuación del calor]]

Por la forma de nuestra ecuación cabría esperar una solución que, además de las condiciones iniciales, tenga (y a simple vista se aprecie) una zona de temperatura máxima en <math> x_0 = 0.5 </math>, donde a ambos lados la temperatura descendería hasta llegar a los extremos, donde la temperatura es constantemente nula.

Vista la solución estacionaria y vista que coincide con la hallada numéricamente, sin embargo, resulta algo difícil operar con estas funciones para hallar la solución homogeneizada, con lo que habitualmente se emplean formas alternativas de resolver el problema que involucran expresar la <math>\delta</math> como una combinación de las funciones de nuestra base de Fourier.

[[Archivo:EvolucionILIA.jpeg|400px|thumb|right|Evolución temporal de la ecuación del calor con fuente térmica]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numba

# Parámetros del problema
L = 1.0 # Longitud del dominio espacial
t0 = 0 #Tiempo inicial
T = 0.1 # Tiempo final
nx = 100 # Número de puntos en la dirección x
nt = 10000 # Número de pasos de tiempo
dx = L / (nx - 1) # diferencia en espacio
dt = (T-t0) / nt # diferencia en tiempo
alpha = 1.0 # Coeficiente de difusión (para la ecuación del calor)
r = alpha * dt / (dx**2) #Coeficiente de estabilidad

# Verificamos que se cumple la cond. de estabilidad para el esquema
if r > 0.5:
raise ValueError(f"La condición de estabilidad no se cumple, 0.5 < {r=}")

#Inicializamos el intervalo discretizado en x
x = np.linspace(0, L, nx)

#Inicializamos el intervalo en t que vamos a emplear
t = np.linspace(t0, T, nt + 1)

#Creamos el mallado en x y t:
X,T_mesh = np.meshgrid(x,t)

# Inicializar la solución u(x, t) con ceros
u = np.zeros((nt + 1, nx))

# Aplicamos las condiciones de frontera e inicial
u[:, 0] = 0
u[:, -1] = 0
u[0, :] = np.sin(2*np.pi*x)

# Calculamos el índice del punto más cercano a x = 0.5
index_source = int(0.5 / dx)

# Evolución temporal
for n in range(nt):
u[n + 1, :] = u[n, :] # Inicializar la siguiente iteración con los valores actuales
for i in range(1, nx - 1):
u[n + 1, i] = u[n, i] + r * (u[n, i + 1] - 2 * u[n, i] + u[n, i - 1])
# Aproximación de la delta de Dirac
u[n + 1, index_source] += 2 * dt / dx

# Crear la figura y el subplot 3D
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficar la superficie, y añadimos etiquetas, barra de color, etc.
surf = ax.plot_surface(X, T_mesh, u, cmap='viridis')
ax.set_xlabel('x')
ax.set_ylabel('t')
ax.set_zlabel('u(x, t)')
ax.set_title('Evolución temporal de la ecuación de calor con fuente (aproximación numérica)')
fig.colorbar(surf, ax=ax, label='u(x, t)')

plt.show()
</syntaxhighlight>

===Interpretación de la solución numérica y comparación con el caso sin fuente===
Los resultados numéricos muestran que efectivamente la fuente térmica localizada en <math> x_0 = 0.5 </math> genera una acumulación de calor en su entorno inmediato. A medida que avanza el tiempo, se observa la disipación progresiva del calor debido a la difusión, que suaviza la temperatura alrededor de este punto, extendiéndola hacia el resto del dominio.

En comparación con el caso sin fuente, donde la temperatura inicial se disipa homogéneamente y tiende a cero en todo el dominio, en este caso se observa un comportamiento diferente: la región en torno a <math> x_0 = 0.5 </math> se mantiene significativamente más caliente durante más tiempo. Esto refleja el efecto de la fuente térmica puntual, que introduce energía de manera continua en el sistema, impidiendo que la temperatura disminuya de forma uniforme.

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Archivo:Solución estacionaria ILIA 2025 8K.png

2025-03-19T11:13:32Z

Nacho: Solución estacionaria ILIA Mates 2025, ecuación del calor.

Solución estacionaria ILIA Mates 2025, ecuación del calor.

Ecuación del calor (Grupo ILIA)

2025-03-19T11:08:52Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo ILIA | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

*'''Ecuación del calor sin fuente térmica:''' resolvemos el problema con condiciones iniciales y de frontera, y obtenemos la solución estacionaria.

*'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

*'''Comparación entre ambas:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\operatorname{sen}(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\operatorname{sen}(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
En los casos sencillos de la ecuación del calor, como los vistos en clase, no existe aporte de calor a nuestro sistema o, si existe, es regular a lo largo del espacio y el tiempo. Sin embargo, en muchas situaciones prácticas, el calor puede ser generado en puntos específicos del dominio. Para modelar este efecto, introducimos una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto concreto <math>x_0</math> de la barra de manera localizada. Así, la ecuación del calor modificada queda como sigue:

<center><math>u_t = u_{xx}+f(x,t)</math></center>

donde <math>f(x,t)</math> es una fuente térmica localizada, que modelamos como:

<center><math>f(x,t)=q(t)\delta(x-x_0)</math></center>

Aquí, <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac, que hace que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Para ilustrar este fenómeno, consideramos el mismo problema de la sección 2 pero con la fuente térmica puntual en <math>x_0=0.5</math>, con una intensidad constante <math>q(t)=2</math>. Obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

Si intentamos resolver este problema suponiendo la existencia de una solución estacionaria, debemos realizar la suposición de que la integral de la función <math>\delta</math> es la función Heaviside, es decir:
<center>
<math>
H(x) =
\begin{cases}
0 & x <0\\
1 & x \geq 0
\end{cases}
</math>
</center>
Con esta información:
<math>
\begin{align*}
-u_{xx}(x) &= 2\delta(x-0.5)\\
\Rightarrow -u_x(x) &= 2\int \delta(x-0.5)dx = 2H(x-0.5) + 2C_1= \begin{cases}
2C_1 &\text{ si } x< 0.5\\
2+2C_1 & \text{ si } x \geq 0.5
\end{cases}\\
\Rightarrow -u(x) &= 2\int H(x-0.5)dx + 2C_1\cdot x\\
\Rightarrow -u(x) & = 2\cdot\left((x-0.5)H(x-0.5) + C_2 + C_1\cdot x\right)\\
\end{align*}
</math>
Evaluando en las condiciones iniciales, llegamos a:
<math>
\begin{align*}
0 &= -u(0) = (-0.5)H(-0.5) + C_2\\
0&= 0 + C_2 \Rightarrow C_2 = 0
\end{align*}
</math>
<math>
\begin{align*}
0 &= -u(1) = (0.5)H(0.5) + C_1+ C_2\\
0&= 0.5 + C_2\\
\Rightarrow C_2 &= -0.5
\end{align*}
</math>
Luego nuestra solución tendría la forma:
<center>
<math>
u(x) = 2\cdot\left(\left(\frac{2x-1}{2}\right)H\left(\frac{2x-1}{2}\right) + \frac{x}{2}\right)
</math>
</center>
Representando nuestra solución estacionaria, llegamos a:

(imagen)

Por la forma de nuestra ecuación cabría esperar una solución que, además de las condiciones iniciales, tenga (y a simple vista se aprecie) una zona de temperatura máxima en <math> x_0 = 0.5 </math>, donde a ambos lados la temperatura descendería hasta llegar a los extremos, donde la temperatura es constantemente nula.

Vista la solución estacionaria y vista que coincide con la hallada numéricamente, sin embargo, resulta algo difícil operar con estas funciones para hallar la solución homogeneizada, con lo que habitualmente se emplean formas alternativas de resolver el problema que involucran expresar la <math>\delta</math> como una combinación de las funciones de nuestra base de Fourier.

[[Archivo:EvolucionILIA.jpeg|400px|thumb|right|Evolución temporal de la ecuación del calor con fuente térmica]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numba

# Parámetros del problema
L = 1.0 # Longitud del dominio espacial
t0 = 0 #Tiempo inicial
T = 0.1 # Tiempo final
nx = 100 # Número de puntos en la dirección x
nt = 10000 # Número de pasos de tiempo
dx = L / (nx - 1) # diferencia en espacio
dt = (T-t0) / nt # diferencia en tiempo
alpha = 1.0 # Coeficiente de difusión (para la ecuación del calor)
r = alpha * dt / (dx**2) #Coeficiente de estabilidad

# Verificamos que se cumple la cond. de estabilidad para el esquema
if r > 0.5:
raise ValueError(f"La condición de estabilidad no se cumple, 0.5 < {r=}")

#Inicializamos el intervalo discretizado en x
x = np.linspace(0, L, nx)

#Inicializamos el intervalo en t que vamos a emplear
t = np.linspace(t0, T, nt + 1)

#Creamos el mallado en x y t:
X,T_mesh = np.meshgrid(x,t)

# Inicializar la solución u(x, t) con ceros
u = np.zeros((nt + 1, nx))

# Aplicamos las condiciones de frontera e inicial
u[:, 0] = 0
u[:, -1] = 0
u[0, :] = np.sin(2*np.pi*x)

# Calculamos el índice del punto más cercano a x = 0.5
index_source = int(0.5 / dx)

# Evolución temporal
for n in range(nt):
u[n + 1, :] = u[n, :] # Inicializar la siguiente iteración con los valores actuales
for i in range(1, nx - 1):
u[n + 1, i] = u[n, i] + r * (u[n, i + 1] - 2 * u[n, i] + u[n, i - 1])
# Aproximación de la delta de Dirac
u[n + 1, index_source] += 2 * dt / dx

# Crear la figura y el subplot 3D
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Graficar la superficie, y añadimos etiquetas, barra de color, etc.
surf = ax.plot_surface(X, T_mesh, u, cmap='viridis')
ax.set_xlabel('x')
ax.set_ylabel('t')
ax.set_zlabel('u(x, t)')
ax.set_title('Evolución temporal de la ecuación de calor con fuente (aproximación numérica)')
fig.colorbar(surf, ax=ax, label='u(x, t)')

plt.show()
</syntaxhighlight>

===Interpretación de la solución numérica y comparación con el caso sin fuente===
Los resultados numéricos muestran que efectivamente la fuente térmica localizada en <math> x_0 = 0.5 </math> genera una acumulación de calor en su entorno inmediato. A medida que avanza el tiempo, se observa la disipación progresiva del calor debido a la difusión, que suaviza la temperatura alrededor de este punto, extendiéndola hacia el resto del dominio.

En comparación con el caso sin fuente, donde la temperatura inicial se disipa homogéneamente y tiende a cero en todo el dominio, en este caso se observa un comportamiento diferente: la región en torno a <math> x_0 = 0.5 </math> se mantiene significativamente más caliente durante más tiempo. Esto refleja el efecto de la fuente térmica puntual, que introduce energía de manera continua en el sistema, impidiendo que la temperatura disminuya de forma uniforme.

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-18T22:33:39Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo MAMBD | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

'''Comparación con el caso sin fuente:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

'''Influencia de la intensidad y duración de la fuente:''' podemos analizar distintos valores de <math> A </math> y ver cómo afectan la propagación térmica.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\operatorname{sen}(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\operatorname{sen}(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
En los casos sencillos de la ecuación del calor, como los vistos en clase, no existe aporte de calor a nuestro sistema o, si existe, es regular a lo largo del espacio y el tiempo. Podemos, sin embargo, tratar de estudiar el caso en el que se introduce una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto concreto <math>x_0</math> de la barra de manera localizada, de manera que la ecuación del calor queda como sigue:
<center><math>u_t = u_{xx}+f(x,t)</math></center>
Donde <math>f(x,t)</math> es de la forma <math>f(x,t)=q(t)\delta(x-x_0)</math>, <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac, que hace que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Si consideramos <math>q(t)=2</math>, <math>x_0=0.5</math> y tomamos el mismo problema de la sección 2 con esta modificación, obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

Tratando de hallar una solución realizando la suposición de existencia de solución estacionaria, llegaríamos a una solución <math>u(x)</math> que no sería continua. Es por ello que otros métodos algo más sofisticados son necesarios para resolver esta ecuación. La idea general, sin embargo, se encuentra en hallar las soluciones generales para nuestro problema homogéneo y, tras esto, describir <math>f(x,t)</math> como suma de elementos de la base de Fourier que hayamos hallado. Debido a la facilidad con la que se integra <math>\delta(x)</math>, esto no supondría un problema.

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-18T22:32:26Z

Nacho:

Ecuación del calor (Grupo ILIA)

2025-03-18T22:05:19Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo MAMBD | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

'''Comparación con el caso sin fuente:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

'''Influencia de la intensidad y duración de la fuente:''' podemos analizar distintos valores de <math> A </math> y ver cómo afectan la propagación térmica.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\operatorname{sen}(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\operatorname{sen}(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
Hemos visto uno de los casos más sencillos de la difusión de calor, pero ahora se introduce una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto <math>x_0</math> de la barra, de manera que la ecuación del calor queda como sigue:
<center><math>u_t = u_{xx}+f(x,t)</math></center>
Donde <math>f(x,t)</math> es de la forma <math>f(x,t)=q(t)\delta(x-x_0)</math>, donde <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac hacer que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Si consideramos <math>q(t)=2</math>, <math>x_0=0.5</math> y tomamos el mismo problema de la sección 2 con esta modificación, obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

Tratando de hallar una solución realizando la suposición de existencia de solución estacionaria, llegaríamos a una solución <math>u(x)</math> que no sería continua. Es por ello que otros métodos algo más sofisticados son necesarios para resolver esta ecuación. La idea general, sin embargo, se encuentra en hallar las soluciones generales para nuestro problema homogéneo y, tras esto, describir <math>f(x,t)</math> como suma de elementos de la base de Fourier que hayamos hallado. Debido a la facilidad con la que se integra <math>\delta(x)</math>, esto no supondría un problema.

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-18T22:04:51Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo MAMBD | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

'''Comparación con el caso sin fuente:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

'''Influencia de la intensidad y duración de la fuente:''' podemos analizar distintos valores de <math> A </math> y ver cómo afectan la propagación térmica.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\operatorname{sen}(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\operatorname{sen}(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
Hemos visto uno de los casos más sencillos de la difusión de calor, pero ahora se introduce una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto <math>x_0</math> de la barra, de manera que la ecuación del calor queda como sigue:
<center><math>u_t = u_{xx}+f(x,t)</math></center>
Donde <math>f(x,t)</math> es de la forma <math>f(x,t)=q(t)\delta(x-x_0)</math>, donde <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac hacer que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Si consideramos <math>q(t)=2</math>, <math>x_0=0.5</math> y tomamos el mismo problema de la sección 2 con esta modificación, obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

Tratando de hallar una solución realizando la suposición de existencia de solución estacionaria, llegaríamos a una solución <math>u(x)<\math> que no sería continua. Es por ello que otros métodos algo más sofisticados son necesarios para resolver esta ecuación. La idea general, sin embargo, se encuentra en hallar las soluciones generales para nuestro problema homogéneo y, tras esto, describir <math>f(x,t)<\math> como suma de elementos de la base de Fourier que hayamos hallado. Debido a la facilidad con la que se integra <math>\delta(x)</math>, esto no supondría un problema.

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-18T22:03:48Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo MAMBD | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

'''Comparación con el caso sin fuente:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

'''Influencia de la intensidad y duración de la fuente:''' podemos analizar distintos valores de <math> A </math> y ver cómo afectan la propagación térmica.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\operatorname{sen}(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\operatorname{sen}(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
Hemos visto uno de los casos más sencillos de la difusión de calor, pero ahora se introduce una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto <math>x_0</math> de la barra, de manera que la ecuación del calor queda como sigue:
<center><math>u_t = u_{xx}+f(x,t)</math></center>
Donde <math>f(x,t)</math> es de la forma <math>f(x,t)=q(t)\delta(x-x_0)</math>, donde <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac hacer que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Si consideramos <math>q(t)=2</math>, <math>x_0=0.5</math> y tomamos el mismo problema de la sección 2 con esta modificación, obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

Tratando de hallar una solución realizando la suposición de existencia de solución estacionaria, llegaríamos a una solución <math>u(x)<\math> que no sería continua. Es por ello que otros métodos algo más sofisticados son necesarios para resolver esta ecuación. La idea general, sin embargo, se encuentra en hallar las soluciones generales para nuestro problema homogéneo y, tras esto, describir <math>f(x,t)<\math> como suma de elementos de la base de Fourier que hayamos hallado. Debido a la facilidad con la que se integra <math>\delta(x)<\math>, esto no supondría un problema.

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-18T21:54:13Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo MAMBD | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

'''Comparación con el caso sin fuente:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

'''Influencia de la intensidad y duración de la fuente:''' podemos analizar distintos valores de <math> A </math> y ver cómo afectan la propagación térmica.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\operatorname{sen}(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\operatorname{sen}(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
Hemos visto uno de los casos más sencillos de la difusión de calor, pero ahora se introduce una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto <math>x_0</math> de la barra, de manera que la ecuación del calor queda como sigue:
<center><math>u_t = u_{xx}+f(x,t)</math></center>
Donde <math>f(x,t)</math> es de la forma <math>f(x,t)=q(t)\delta(x-x_0)</math>, donde <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac hacer que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Si consideramos <math>q(t)=2</math>, <math>x_0=0.5</math> y tomamos el mismo problema de la sección 2 con esta modificación, obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-18T21:53:53Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo MAMBD | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

'''Comparación con el caso sin fuente:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

'''Influencia de la intensidad y duración de la fuente:''' podemos analizar distintos valores de <math> A </math> y ver cómo afectan la propagación térmica.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\sen(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \sen(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\sen(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
Hemos visto uno de los casos más sencillos de la difusión de calor, pero ahora se introduce una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto <math>x_0</math> de la barra, de manera que la ecuación del calor queda como sigue:
<center><math>u_t = u_{xx}+f(x,t)</math></center>
Donde <math>f(x,t)</math> es de la forma <math>f(x,t)=q(t)\delta(x-x_0)</math>, donde <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac hacer que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Si consideramos <math>q(t)=2</math>, <math>x_0=0.5</math> y tomamos el mismo problema de la sección 2 con esta modificación, obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \operatorname{sen}(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-18T21:53:22Z

Nacho: \sen

{{ TrabajoED | Ecuación del calor. Grupo MAMBD | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

'''Comparación con el caso sin fuente:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

'''Influencia de la intensidad y duración de la fuente:''' podemos analizar distintos valores de <math> A </math> y ver cómo afectan la propagación térmica.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=\sen(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \sen(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=\sen(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
Hemos visto uno de los casos más sencillos de la difusión de calor, pero ahora se introduce una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto <math>x_0</math> de la barra, de manera que la ecuación del calor queda como sigue:
<center><math>u_t = u_{xx}+f(x,t)</math></center>
Donde <math>f(x,t)</math> es de la forma <math>f(x,t)=q(t)\delta(x-x_0)</math>, donde <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac hacer que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Si consideramos <math>q(t)=2</math>, <math>x_0=0.5</math> y tomamos el mismo problema de la sección 2 con esta modificación, obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = \sen(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-18T21:50:58Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo MAMBD | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

'''Comparación con el caso sin fuente:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

'''Influencia de la intensidad y duración de la fuente:''' podemos analizar distintos valores de <math> A </math> y ver cómo afectan la propagación térmica.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=sen(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = sen(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=sen(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
Hemos visto uno de los casos más sencillos de la difusión de calor, pero ahora se introduce una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto <math>x_0</math> de la barra, de manera que la ecuación del calor queda como sigue:
<center><math>u_t = u_{xx}+f(x,t)</math></center>
Donde <math>f(x,t)</math> es de la forma <math>f(x,t)=q(t)\delta(x-x_0)</math>, donde <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac hacer que el calor se añada únicamente en el punto <math>x_0</math>. Al emplear la distribución <math>\delta</math> de Dirac, estamos imponiendo que esta adición energética (calorífica) se encuentre extremadamente localizada, como la acción de un láser sobre una barra que simplificamos como unidimensional.

Si consideramos <math>q(t)=2</math>, <math>x_0=0.5</math> y tomamos el mismo problema de la sección 2 con esta modificación, obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = sen(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Ecuación del calor (Grupo ILIA)

2025-03-18T21:48:44Z

Nacho:

{{ TrabajoED | Ecuación del calor. Grupo MAMBD | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Alicia Ruiz Dominguez, Luis Ramos Ortiz }}

=Introducción=
La ecuación del calor es una de las ecuaciones en derivadas parciales más fundamentales en la física y las matemáticas aplicadas, modelando la difusión de la temperatura en distintos medios. Su estudio es esencial en múltiples disciplinas, desde la ingeniería térmica hasta la biomedicina, donde se analiza la propagación del calor en tejidos biológicos. En este trabajo, estudiaremos el comportamiento de esta ecuación en una barra unidimensional aislada en el intervalo [0,1], imponiendo condiciones de frontera con temperatura constante.

En la vida real, las fuentes de calor no necesariamente tienen por qué estar en los extremos, por lo que también buscamos un enfoque más aplicado y realista. Nos enfocaremos en la propagación del calor cuando existe una fuente térmica localizada, es decir, introduciremos una fuente de calor puntual en algún punto en el interior de la barra (0,1) y veremos cómo se comporta la ecuación del calor. En la práctica, muchas aplicaciones incluyen fuentes térmicas, como calefactores, reacciones químicas o dispositivos electrónicos que generan calor; y esto tiene aplicaciones en procesos industriales, generación de energía y modelización de sistemas térmicos.

En resumen, exploraremos cómo la presencia de una fuente de calor afecta a la distribución de la temperatura en el tiempo, resolviendo el problema tanto analíticamente como numéricamente. A través de esta aproximación, podremos comprender mejor la influencia de fuentes térmicas en sistemas difusivos y validar métodos numéricos para resolver ecuaciones en derivadas parciales. Estudiaremos varios aspectos:

'''Ecuación del calor con fuente:''' en este caso, la ecuación incluye un término <math> f(x,t) </math> que representa una generación de calor interna. Esto hace que la temperatura no solo se difunda, sino que también aumente o disminuya dependiendo de la fuente.

'''Comparación con el caso sin fuente:''' veremos cómo la solución cambia al introducir un calentamiento localizado, observando si se alcanza un estado estacionario diferente o si la temperatura sigue variando en el tiempo.

'''Influencia de la intensidad y duración de la fuente:''' podemos analizar distintos valores de <math> A </math> y ver cómo afectan la propagación térmica.

=Ecuación del calor=
La ecuación de difusión del calor original sin fuentes de calor externas viene dada por:
<math>
u_t=u_{xx}
</math>
donde la función u(x,t) es la función temperatura en cada posición e instante de tiempo, <math>u_t</math> la derivada temporal y <math>u_{xx}</math> la segunda derivada espacial, que modela la difusión del calor.

Si consideramos que la condición inicial en <math>t=0</math> es <math>u(x,0)=sen(x)</math>, podemos obtener el siguiente problema de ecuación del calor con condiciones frontera:
<center><math>
\begin{cases}
u_t - u_{xx} = 0, & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = sen(2\pi x), & x \in [0,1]
\end{cases}
</math></center>
Resolviendo este problema obtenemos que la solución estacionaria es:
<center><math>u_s(x)=0</math></center>
y la solución general:

<center><math>u(x,t)=sen(2\pi x)e^{-4\pi^{2}t}</math></center>

Vamos a graficar la solución.

[[Archivo:soluil.png|400px|thumb|right|Solución de la ecuación del calor]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# puntos de la malla
x = np.linspace(0, 1, 50)
t = np.linspace(0, 0.5, 50)

X, T = np.meshgrid(x, t) # malla
U = np.sin(2 * np.pi * X) * np.exp(-4 * np.pi**2 * T) # sol general

# figura
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

# grafica
ax.plot_surface(X, T, U, cmap='viridis')
ax.set_xlabel('Posición x')
ax.set_ylabel('Tiempo t')
ax.set_zlabel('Temperatura u(x,t)')
ax.set_title('Solución de la ecuación del calor')

plt.show()
</syntaxhighlight>

Como podemos ver la solución tiende rápidamente a la solución estacionaria en el que toda la barra está a 0 grados, que es lógico si tenemos en cuenta que los extremos tienen temperatura constante de 0.

=Ecuación del calor con fuente térmica puntual=
Hemos visto uno de los casos más sencillos de la difusión de calor, pero ahora se introduce una función <math>f(x,t)</math> que representa un nuevo foco de calor en un punto <math>x_0</math> de la barra, de manera que la ecuación del calor queda como sigue:
<center><math>u_t = u_{xx}+f(x,t)</math></center>
Donde <math>f(x,t)</math> es de la forma <math>f(x,t)=q(t)\delta(x-x_0)</math>, donde <math>q(t)</math> representa la cantidad de calor que se añade en función del tiempo y <math>\delta(x-x_0)</math> es la delta de Dirac hacer que el calor se añada únicamente en el punto <math>x_0</math>. Esto podría representar la adición de calor de manera muy localizada, casi infinitesimal, como la acción de un láser.

Si consideramos <math>q(t)=2</math>, <math>x_0=0.5</math> y tomamos el mismo problema de la sección 2 con esta modificación, obtenemos el siguiente problema:

<center><math>
\begin{cases}
u_t - u_{xx} = f(x,t), & x \in [0,1], \quad t > 0 \\
u(0,t) = 0, & t > 0 \\
u(1,t) = 0, & t > 0 \\
u(x,0) = sen(2\pi x), & x \in [0,1] \\
f(x,t)=2\delta(x-0.5)
\end{cases}
</math></center>

[[Categoría:EDP]]

[[Categoría:EDP24/25]]

Series de Fourier (Grupo ILIA)

2025-02-13T07:32:05Z

Nacho: Actualizado el código.

{{ TrabajoED | Series de Fourier (Grupo ILIA) | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP24/25|2024-25]] | Ignacio Campos Paños, Ignacio Martínez Cerezo, Luis Ramos Ortiz, Alicia Ruiz Dominguez }}

=Introducción=

En una amplia gama de problemas de ingeniería y matemáticas aparecen funciones periódicas que se necesitan aproximar mediante sumas de funciones trigonométricas, lo que conduce a las '''series de Fourier'''.

Estas series constituyen una herramienta fundamental en la resolución de ecuaciones en derivadas parciales y otros muchos ámbitos de la ciencia. La idea principal es que una función <math>f(x)</math>, definida en un espacio de Hilbert <math>L^2(-\pi,\pi)</math>, puede expresarse como una combinación infinita de funciones trigonométricas de la forma:

<center><math>
f(x) \approx \frac{d_0}{2\pi} + \sum_{n=1}^{\infty} d_n \frac{1}{\sqrt{\pi}} \cos(nx) + \sum_{n=1}^{\infty}c_n \frac{1}{\sqrt{\pi}} \sin(nx)
</math></center>

Los coeficientes <math>d_0</math>, <math>d_n</math> y <math>c_n</math> son los '''coeficientes de Fourier''' y se definen de la siguiente manera:

<math> \quad
d_0 = \int_{-\pi}^{\pi} f(x) \frac{1}{\sqrt{\pi}} dx
</math>

<math> \quad
d_n = \int_{-\pi}^{\pi} f(x) \frac{1}{\sqrt{\pi}}cos(nx) dx
</math>

<math> \quad
c_n = \int_{-\pi}^{\pi} f(x) \frac{1}{\sqrt{\pi}}sen(nx) dx
</math>

Este método permite descomponer funciones periódicas en sus componentes fundamentales, lo que es de gran utilidad en física, ingeniería y matemáticas aplicadas. A continuación, se presentan las primeras funciones base utilizadas en la expansión en series de Fourier.

=Base trigonométrica=
Para comprender mejor la construcción de las series de Fourier y poder visualizar las funciones base mencionadas, representamos gráficamente los primeros términos de la base trigonométrica <math> \mathcal{B} := \left\{ \frac{1}{2}, \cos(n\pi x), \sin(n\pi x) \right\}_{n \in \mathbb{N}} </math> en el intervalo <math> [ -1, 1 ] </math> mediante un código en Python. Esto nos permitirá observar cómo estas funciones elementales forman una '''base ortonormal''' en el espacio <math> L^2( [-1,1]) </math> y cómo, mediante combinaciones lineales de estas, podemos aproximar funciones arbitrarias.

[[Archivo:GraficasILIA.jpeg|450px|thumb|right|Primeros términos de la Base Trigonométrica]]

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt

def base_fourier_cos(n: int) -> list[callable]:
"""Genera los n primeros términos de cosenos de la base trigonométrica de fourier

Args:
n (int): Número de términos

Returns:
list[callable]: lista con funciones lambda, ordenada según su posición en la base.
"""
basis_functions = []
for k in range(1, n + 1):
basis_functions.append(lambda x, k=k: np.cos(np.pi * k * x))
return basis_functions

def base_fourier_sen(n: int) -> list[callable]:
"""Genera los n primeros términos de senos de la base trigonométrica de fourier

Args:
n (int): Número de términos

Returns:
list[callable]: lista con funciones lambda, ordenada según su posición en la base.
"""
basis_functions = []
for k in range(1, n + 1):
basis_functions.append(lambda x, k=k: np.sin(np.pi * k * x))
return basis_functions

# Parámetros
X = np.linspace(-1, 1, 1000)
# número de elementos de la base (1, cos(n pi x), sen(n pi x))
n = 10

colors = colors = [
"#0000FF",
"#0033CC",
"#0066CC",
"#0099FF",
"#33CCFF",
"#66CCCC",
"#CC9966",
"#FF6633",
"#FF3300",
"#FF0000",
]

# Obtener funciones base

base = [lambda x: 1] + base_fourier_cos(n) + base_fourier_sen(n)

# Graficar

plt.subplots(3, 1, figsize=(15, 15), dpi=300)

plt.subplot(3, 1, 1)
plt.grid()
plt.title("Término constante")
plt.plot([-1, 1], [1 / 2, 1 / 2], color=colors[-1], label="Término constante")

plt.subplot(3, 1, 2)
plt.grid()
plt.title("Términos en coseno")

for i in range(1, n + 1):
plt.plot(X, base[i](X), color=colors[i - 1], label=f"cos({str(i)*(i>1)}πx)")
plt.legend(loc="right")

plt.subplot(3, 1, 3)
plt.grid()
plt.title("Términos en seno")

for i in range(n + 1, len(base)):
plt.plot(X, base[i](X), color=colors[i - n - 1], label=f"sen({str(i-n) * ((i-n) > 1)}πx)")
plt.legend()
</syntaxhighlight>

Al graficar estos términos, podemos apreciar cómo la combinación de estos elementos nos permite aproximar funciones periódicas arbitrarias, tal y como buscábamos.
La relevancia de esta base radica en su aplicación en la aproximación de funciones mediante series trigonométricas. En particular, la expansión de Fourier de una función \( f(x) \) en esta base se expresa como:

<center> <math>
f(x) \approx \sum_{n=1}^{\infty} c_n e_n \quad \text{con} \quad c_n = \langle f, e_n \rangle
</math></center>

Donde \( e_n \) es cada uno de los términos de la base <math> \left\{ \frac{1}{2}, \cos(n\pi x), \sin(n\pi x) \right\}_{n \in \mathbb{N}} </math>, y <math> c_n </math> son los coeficientes que se calculan mediante el producto interno de <math> f(x) </math> con los elementos de la base.

Como se puede observar, a medida que el parámetro <math> n </math> aumenta, los términos oscilan con un periodo cada vez menor, concretamente <math> T = \frac{2}{n} </math>, lo que refleja una mayor "frecuencia" en las oscilaciones. Esta característica es esencial en la aproximación de funciones suaves por medio de las series de Fourier, donde las funciones periódicas se aproximan cada vez con mayor precisión mediante una combinación lineal de estos términos básicos.

[[Categoría:EDP]]
[[Categoría:EDP24/25]]

Series de Fourier (Grupo ILIA)

2025-02-12T18:20:21Z

Nacho: