Mostrando entradas con la etiqueta Matlab. Mostrar todas las entradas
Mostrando entradas con la etiqueta Matlab. Mostrar todas las entradas

sábado, 17 de septiembre de 2011

Triangulación y convexidad


Este es un programa en MATLAB, clickea en el axes y luego de varias veces haz clic derecho. Verás la triangulación por Delaunay y la capsula convexa. Si desean ver un poco de teoría sobre convexidad y cápsula convexa, revisen : Functional Analisys with Applications , Zeidler.

clear all
clc
figure(1)
xlim([0 1])
ylim([0 1])
hold on
i=0;
X=[];
Y=[];
while 1
    [x,y,buttom]=ginput(1);
    if buttom==3
        break
    end
    plot(x,y,'ok')
    i=i+1;
    X(i)=x;
    Y(i)=y;  
end

% si usas Octave solo cambia esto por lo último

%T=delaunay(X',Y');
%k = convhull(X',Y');
%triplot(T,X,Y)
%plot(X'(k),Y'(k), '-rs')


dt=DelaunayTri(X',Y');
k = convexHull(dt);
triplot(dt)
plot(dt.X(k,1),dt.X(k,2), 'rs')


lunes, 15 de agosto de 2011

Archivos .p en MATLAB


Los archivos con extensión .p o archivos-p en Matlab son archivos pre-compilados
a partir de un archivo-m. Las ventajas de un archivo-p respecto de un archivo-m son:

1. Dado que los archivos-p son pre-compilados, entonces se ejecutan más rápidamente que los archivos-m
2. En un archivo-p se puede esconder el código de un algoritmo si éste se desea
mantener secreto.


La desventaja de los archivos-p es que dependen de la plataforma sobre la cual fueron
pre-compilados y por lo tanto no podrán ser ejecutados en una plataforma distinta.
Para construir un archivo-p a partir de un archivo-m se puede usa el comando Matlab pcode.

Example:

Crear un archivo-p a partir archivo-m llamado prueba.m y dejar ese archivo prueba.p en el directorio actual:
>>pcode -inplace prueba.m

lunes, 8 de agosto de 2011

Application to the tube chock problem


En el libro An Introducctión to Scientific Computing Twelve Computational Projects Solved with MATLAB  presentan doce proyectos, que si bien estan resueltos, son un buen ejercicio eso días en los que no hay deberes. Entre mis intereses están los métodos numéricos para resolver las ecuaciones que gobiernan la dinámica de los fluidos (CFD-Dinámica de fluidos Computacional). Los proyectos 10 y 12 tratan estas ecuaciones. Hay algunas cuestiones importantes en la solución numérica de estas ecuaciones, que tienen que ver con la matemática de las ecuaciones, soluciones discontinuas, condiciones iniciales discontinuas; ver la matemática necesaria para entender estas ecuaciones es una de mis expectativas del curso de EDP 2 que voy a llevar este ciclo. 
No tengo MATLAB por el momento, así que me las arregle, use SAGE y lo programe en Python; estoy obteniendo los resultados.



class Tubechock:
    def __init__(self):
        self.gamma=1.4
        self.cfl=0.95
        self.g1=line([])
        self.g2=line([])
        self.g3=line([])
        self.g4=line([])
        self.M=81
        self.x0=0.5
        self.rhoL=8.0
        self.rhoR=1.0
        self.pL=10.0/self.gamma
        self.pR=1.0/self.gamma
        self.UL=0
        self.UR=0
        self.rhoUL=self.rhoL*self.UL
        self.rhoUR=self.rhoR*self.UR
        self.EL=self.pL/(self.gamma-1)
        self.ER=self.pR/(self.gamma-1)
        self.dx=1/(self.M-1)
        self.dt=0
        self.x=[i*self.dx for i in range(self.M)]
        self.t=0
        self.w=[[0 for j in range(3)]for i in range(self.M)]
        self.F=[[0 for j in range(3)]for i in range(self.M)]
        self.FF=[[0 for j in range(3)]for i in range(self.M-1)]
        for i in range(self.M):
            if (self.x[i]<=self.x0):
                self.w[i]=[self.rhoL,self.rhoUL,self.EL]
            if (self.x[i]>self.x0):
                self.w[i]=[self.rhoR,self.rhoUR,self.ER]
    
    
    def plot_d(self):        
        xvsd=[[self.x[i],self.w[i][0]] for i in range(self.M)]
        self.g1=line(xvsd,rgbcolor=(3/4,1/2,5/8))
        self.g1.axes_labels(['$x$',r'$\rho$'])
        self.g1.fontsize(15)
        
    
    
    def plot_v(self):
        xvsv=[[self.x[i],self.w[i][1]/self.w[i][0]] for i in range(self.M)]        
        self.g2=line(xvsv,rgbcolor=(1/4,1/4,5/8))
        self.g2.axes_labels(['$x$','$v$'])
        self.g2.fontsize(15)
    
    
    def plot_p(self):
        xvsp=[]
        for i in range(self.M):
            k=(self.w[i][2]-0.5*self.w[i][1]*self.w[i][1]/self.w[i][0])*(self.gamma-1)
            xvsp.append([self.x[i],k])
        self.g3=line(xvsp,rgbcolor=(6/8,3/4,3/8))
        self.g3.axes_labels(['$x$','$p$'])
        self.g3.fontsize(15)
 
 
    def plot_T(self):
        xvsT=[]
        for i in range(self.M):
            k=(self.w[i][2]-0.5*self.w[i][1]*self.w[i][1]/self.w[i][0])*(self.gamma-1)
            xvsT.append([self.x[i],k/self.w[i][0]])
        self.g4=line(xvsT,rgbcolor=(3/4,3/5,1/3))
        self.g4.axes_labels(['$x$','$T$'])
        self.g4.fontsize(15)
        
    
    def graf(self):
        self.plot_d()
        self.plot_v()
        self.plot_p()
        self.plot_T()
        g=graphics_array([[self.g1,self.g2],[self.g3,self.g4]])
        g.show(frame=True, axes=True, figsize=[12,8])
        
    
    
    def Dt(self):
        uloc=[(self.w[i][1]/self.w[i][0]) for i in range(self.M)]
        press=[(self.gamma-1)*(self.w[i][2]-0.5*self.w[i][1]*uloc[i]) for i in range(self.M)]
        k=self.gamma*press[i]/self.w[i][0]        
        a=[((k)^(0.5)) for i in range(self.M)]
        max=[(abs(uloc[i])+a[i]) for i in range(self.M)]
        max.sort()
        self.dt=0.95*self.dx/max[self.M-1]
        
        
    
    def Fw(self):
        for i in range(self.M):            
            uloc  = self.w[i][1]/self.w[i][0]
            rhou2 = self.w[i][1]*uloc
            press = (0.4)*(self.w[i][2]-0.5*rhou2)
            self.F[i]=[self.w[i][1],rhou2+press,(self.w[i][2]+press)*uloc]
            
    def FFw(self):
        for i in range(self.M-1):
            pas=[0.5*(self.w[i][j]+self.w[i+1][j])-0.5*(self.dt/self.dx)*(self.F[i+1][j]-self.F[i][j]) for j in range(3)]
            uloc  = pas[1]/pas[0]
            rhou2 = pas[1]*uloc
            press = (0.4)*(pas[2]-0.5*rhou2)
            self.FF[i]=[pas[1],rhou2+press,(pas[2]+press)*uloc]
                
    
    
    def sol(self,tf=0.2):
        while (self.t<tf):                    
            self.Dt()
            self.Fw()
            self.FFw()
            for i in range(1,self.M-1):
                self.w[i][0]=self.w[i][0]-(self.dt/self.dx)*(self.FF[i][0]-self.FF[i-1][0])
                self.w[i][1]=self.w[i][1]-(self.dt/self.dx)*(self.FF[i][1]-self.FF[i-1][1])
                self.w[i][2]=self.w[i][2]-(self.dt/self.dx)*(self.FF[i][2]-self.FF[i-1][2])
            self.t=self.t+self.dt            
        
 
mysol=Tubechock()
mysol.sol()
mysol.graf()


martes, 16 de noviembre de 2010

Laplace

Ecuación de Laplace en Octave

Computación Científica

Facultad de Ciencias Matemáticas

Universidad Nacional Mayor de San Marcos


22 de octubre de 2010

Resumen
            En este proyecto resolvemos numéricamente la ecuación de Laplace usando el método de diferencias finitas. Hacemos uso de Octave para presentar los resultados.

Introducción

Las ecuaciones en derivadas parciales(PDE's) mas estudiadas se clasifican en hiperbólicas, parabólicas y elípticas. Dado que estas representan modelos muy aproximados de fénomenos en la naturaleza, es necesario hallar su solución, al menos de manera aproximada.
Presentaremos un esquema númerico de solución para una ecuacíon de tipo elíptico, la ecuación de Laplace.




Lo siquiente es el código desarrollado en Octave y un resultado obtenido. Éstare presentando mas detalles.

function V=Laplace(xi,yi,n,m,fr,f)
%  laplaciano(u)=f(x,y) 
%   u(frontera)=h(x,y)
%n: numero de intervalos en x
%n+1 puntos x
%m: numero de intervalos en y
%m+1 puntos y

%------------------------
%tamaños de paso;
h=(xi(2)-xi(1))/n;
g=(yi(2)-yi(1))/m;
%-------------------------
%mallado
x=linspace(xi(1),xi(2),n+1);
y=linspace(yi(1),yi(2),m+1);
V=zeros(n+1,m+1);
%---------------------------
%funciones
F=inline(f,'x','y');
H=inline(fr,'x','y');
%-----------------------------
%construyendo la matriz A
%coeficientes
a=2*(1/(h^2)+1/(g^2));
b=-1/(h^2);
c=-1/(g^2);
%matrices de tamaño n-1
M_1=trigeneral(a,b,n-1); 
M_2=trigeneral(c,0,n-1);
%m-1 bloques
A=trigeneral(M_1,M_2,m-1);
%--------------------------------
%en la frontera
for i=1:n+1
    V(i,1)=H(x(i),yi(1));
    V(i,m+1)=H(x(i),yi(2));
end
for i=1:m+1
    V(1,i)=H(xi(1),y(i));
    V(n+1,i)=H(xi(2),y(i));
end

%-------------------------
%los V(i,j) incognitas so los que estan en el interior
% 2<=i<=n ; 2<=j<=m
%Ahora formaremos elvector B del sistem : Av=B
B1=zeros((n-1)*(m-1),1);
B2=zeros((n-1)*(m-1),1);
B3=zeros((n-1)*(m-1),1);
B4=zeros((n-1)*(m-1),1);
%---------------------------
%la parte con f
for j=2:m
    for i=2:n
        B1( (j-2)*(n-1) +(i-1))=F(x(i),y(j));
    end
end

B2(1:n-1:(n-1)*(m-1)-(n-2))=(-b)*V(1,2:m);

B3(n-1:n-1:(n-1)*(m-1))=(-b)*V(n+1,2:m);

B4(1:n-1)=(-c)*V(2:n,1);
B4((n-1)*(m-2)+1:(n-1)*(m-1))=(-c)*V(2:n,m+1);
%------------------
B=B1+B2+B3+B4;
w=A\B;
for j=2:m
    for i=2:n
        V(i,j)=w((j-2)*(n-1) +(i-1));
    end
end

[X,Y]=meshgrid(x,y);

surf(X,Y,V')


function M=trigeneral(A,B,num)
m=size(A,1);TM=m*num;M=zeros(TM);
M(1:m,1:m)=A;
M(1:m,m+1:2*m)=B;
for i=m+1:m:TM-2*m+1,k=i+m-1;M(i:k,i:i+m-1)=A;M(i:k,i-m:i-1)=B;...
M(i:k,i+m:i+2*m-1)=B;end
k=TM+1-m;
M(k:TM,TM+1-m:TM)=A; 
M(k:TM,TM-2*m+1:TM-m)=B;