Codigo Simulacion

1 function miSimulacion ()
2 close all ;
3 clear all ;
4 clc ;
5

6 % Declaracion de las constantes de permitividad y

permabilidad del vacio
7

8 epsilon0 =8.85418 e -12;

9

10 % Registro de epsilon relativo

11 eps ilon0_ relati va = input ( ’ Ingrese el valor de
epsilon relativo : ’) ;
12 if isempty ( eps ilon0_ relat iva ) ||
epsilon0_relativa <=0
13 disp ( ’ No se ingreso , ningun valor , tomando 4
como valor ’) ;
14 eps ilon0_ relati va = 4;
15 end
16

17

18 mu0 =4* pi *1 e -7;

19

20 % Registro de mu relativo
21 mu_relativa = input ( ’ Ingrese el valor de mu
relativo : ’) ;
22 if isempty ( mu_relativa ) || mu_relativa <=0
23 disp ( ’ No se ingreso , ningun valor , tomando 1
como valor ’) ;
24 mu_relativa = 1;
25 end
26

27 % parametros constitutivos del material

28 epsilon_a_usarse = epsilon0 * e psilon 0_rela tiva ;
29 mu_a_usarse = mu0 * mu_relativa ;
30

31

32 % Calculo de la conductancia
33

34 % entendemos como relacion de conductancia , al

valor conductancia
35 % sobre ( w * epsilon ) visto en las formulas , este
valor se pide de

1
36 % esta manera unicamente para asegurar que la
simulacion funcione
37 % correctamente
38 r e l a c i o n _ c o n d u c t a n c i a = input ( ’ Ingrese la relacion
de conductancia : ’) ;
39 if isempty ( r e l a c i o n _ c o n d u c t a n c i a ) || mu_relativa <0
40 disp ( ’ No se ingreso , ningun valor , tomando 1
como valor ’) ;
41 r e l a c i o n _ c o n d u c t a n c i a = 1;
42 end
43

44

45

46 % Registro del valor de la frecuencia

47 f_real = input ( ’ Ingrese el valor de la frecuencia
( f ) : ’) ;
48

49 if isempty ( f_real ) || f_real <=0

50 disp ( ’ No se ingreso , ningun valor , tomando 50
como valor ’) ;
51 f_real = 50;
52 end
53

54

55 % Ingresamos la magnitud de E
56 Emax = input ( ’ Ingrese magnitud de E : ’) ;
57

58 if isempty ( Emax ) || Emax <=0

59 disp ( ’ No se ingreso , ningun valor , generando
valor ’) ;
60 Emax = 1;
61 end
62

63 % Ingresamos espaceado entre vectores

64 espVect = input ( ’ Ingrese espaciado entre vectores ,
UNICAMENTE DE 5 -6 -7 -8 -9 -10 , ENTEROS : ’) ;
65

66 if isempty ( espVect ) || espVect <=0 || ( espVect > 4

&& espVect < 11 && isinteger ( espVect ) )
67 disp ( ’ El valor ingresado no es v l i d o , se
g e n e r a r un valor predeterminado . ’) ;
68 espVect = 10;
69 end
70

71

72

2
73 % Calculo del periodo
74 T_real =1/ f_real ;
75

76

77 % Calculo de la velocidad angular

78 w_real = 2* pi * f_real ;
79

80

81 % Calculo Auxiliar de la raiz cuadrada del

producto de a usarse y a
82 % usarse
83 auxRaizProducto =
sqrt ( epsilon_a_usarse * mu_a_usarse ) ;
84

85

86 % Calculo Auxiliar de la raiz cuadrada de /

87 a u xD i v is i o nP r o du c t o =
sqrt ( mu_a_usarse / epsilon_a_usarse ) ;
88

89 % Calculo Auxiliar 3 , constante de multiplicacion

de alfa y beta
90 auxiliarMultiplicador =
w_real * auxRaizProducto / sqrt (2) ;
91

92

93 % calculo de constante de atenuacion

94 alfa =
a u x i l i a r M u l t i p l i c a d o r * sqrt ( sqrt (( r e l a c i o n _ c o n d u c t a n c i a ) ^2+1) -1) ;
95

96 % calculo de constante de fase

97 beta =
a u x i l i a r M u l t i p l i c a d o r * sqrt ( sqrt (( r e l a c i o n _ c o n d u c t a n c i a ) ^2+1) +1) ;
98

99

100 % Longitud de onda

101

102 lambda_real =2* pi / beta ;

103

104 % Velocidad de fase

105

106 vp = w_real / beta ;

107

108 % profundidad de superficie

109

110 prof_sup =1/ alfa ;

111

3
112

113 % impedancia intrinseca

114

115 n = a u x Di v i si o n Pr o d uc t o /((1+ r e l a c i o n _ c o n d u c t a n c i a ^2) ^(1/4) ) ;

116

117 % desfase de ondas

118

119 theta =1/2* atan ( r e l a c i o n _ c o n d u c t a n c i a ) ;

120

121 % Calculando campo H , magnitud

122

123 Hmax = Emax / n ;

124

125

126

127 % Crear el b o t n de pausa

128 hStopButton = uicontrol ( ’ Style ’ , ’ pushbutton ’ , ...
129 ’ String ’ , ’ Detener ’ , ...
130 ’ Position ’ , [20 20 100
40] , ...
131 ’ Callback ’ ,
@stopSimulation ) ;
132

133 % Crear checkbox para controlar la visibilidad de

las ondas
134 hCheckbox = uicontrol ( ’ Style ’ , ’ checkbox ’ , ...
135 ’ String ’ , ’ Mostrar ondas ’ ,
...
136 ’ Value ’ , 1 , ...
137 ’ Position ’ , [140 20 150
40] , ...
138 ’ Callback ’ , @toggleWaves ) ;
139

140 % Crear b o t n para mostrar datos

141 hDataButton = uicontrol ( ’ Style ’ , ’ pushbutton ’ , ...
142 ’ String ’ , ’ Datos ’ , ...
143 ’ Position ’ , [270 20 100 40] ,
...
144 ’ Callback ’ , @showData ) ;
145

146 % Crear un uicontrol de texto para mostrar los

datos
147 hDataText = uicontrol ( ’ Style ’ , ’ text ’ , ...
148 ’ String ’ , ’ ’ , ...
149 ’ Position ’ , [400 40 800 90] , ...
150 ’ FontSize ’ , 10) ;

4
151

152 % F u n c i n para mostrar datos

153 function showData (~ , ~)
154 % Actualizar el texto con los datos
155 set ( hDataText , ’ String ’ , [ ’ Frecuencia ( f ) : ’ ,
num2str ( f_real ) , ...
156 ’ - Periodo ( T ) : ’ ,
num2str ( T_real ) , ...
157 ’ - Permitividad : ’ ,
num2str ( epsilon_a_usarse ) ,
...
158 ’ - Permitividad del
vacio : ’ ,
num2str ( epsilon0 ) ,
...
159 ’ - Permeabilidad : ’ ,
num2str ( mu_a_usarse ) ,
...
160 ’ - Permeabilidad del
vacio : ’ ,
num2str ( mu0 ) , ...
161 ’ - Theta : ’ ,
num2str ( theta ) , ...
162 ’ - velocidad angular :
’ , num2str ( w_real ) ,
...
163 ’ - constante de
atenuacion ’ ,
num2str ( alfa ) , ...
164 ’ - constante de fase
’ , num2str ( beta ) , ...
165 ’ - velocidad de fase
’ , num2str ( vp ) , ...
166 ’ - Longitud de onda
’,
num2str ( lambda_real ) ,
...
167 ’ - Profundidad de
superficie ’ ,
num2str ( prof_sup ) ,
...
168 ’ - Magnitud de E : ’ ,
num2str ( Emax ) , ...
169 ’ - Magnitud de H : ’ ,
num2str ( Hmax ) ]) ;
170 end

5
171

172

173 % Ajustes
174 % Primer ajuste , bajamos la frecuencia para que
sea visible
175 f = f_real /10;
176

177 % 2 do ajuste , calculamos el nuevo w para esa

frecuencia
178 w = 2* pi * f ;
179

180

181

182

183

184 alfaSimulado = alfa *10^( valorDeAjuste ( beta ) ) ;

185

186 betaSimulado = m u l t i p l i c a r H a s t a U n a C i f r a ( beta ) ;

187

188

189

190 % Ingresamos valor de ajuste de caida , si lo

dejamos como esta , la onda
191 % caera rapidamente de magnitud
192 valCaida = input ( ’ Ingrese la caida del 1 al 10 ,
10 es caida rapida ’) ;
193

194 if isempty ( valCaida )

195 disp ( ’ El valor ingresado no es v l i d o , se
g e n e r a r un valor predeterminado . ’) ;
196 valCaida = 8;
197 end
198

199 auxCaida = valCaida /10;

200

201

202 alfaSimulado = alfaSimulado * auxCaida ;

203

204 betaSimulado = betaSimulado * auxCaida ;

205

206

207

208

209 HSimulado = Hmax *10;

210

211 % Ingresamos el acercamiento , 1 es cerca y mas

6
 grande , es mas lejos
212 valZoom = input ( ’ Ingrese el acercamiento del 1 -5 ,
1 es cerca , no ingrese otro tipo de valores ’) ;
213

214 if isempty ( valZoom )

215 disp ( ’ El valor ingresado no es v l i d o , se
g e n e r a r un valor predeterminado . ’) ;
216 valZoom = 1;
217 end
218

219 auxZoom =100* valZoom ;

220

221 z = linspace (0 ,8 , auxZoom ) ;

222 m = zeros (1 , auxZoom ) ;
223

224 % Loop de la s i m u l a c i n
225 for j = 1:0.01:5
226 i = j - 1;
227

228 H =
HSimulado .* exp (( -1) .* alfaSimulado .* z ) .* cos ( w .* i
- betaSimulado .* z ) ;
229 E =
Emax .* exp (( -1) .* alfaSimulado .* z ) .* cos ( w .* i
- betaSimulado .* z - theta ) ;
230

231

232 % Plotear campos H y E

233 hPlotB = plot3 (z ,H ,m , ’r ’) ;
234 hold on ;
235 hPlotE = plot3 (z ,m ,E , ’k ’) ;
236

237 % Factor de escala para ajustar la longitud

de los vectores y que lleguen
238 % hasta la onda que les corresponde
239 escala_longitud = 1.05;
240

241 % Agregar vectores desde el eje X hasta la

onda generada
242 hold on ;
243 for k = 1: espVect : length ( z )
244 % Coordenadas de los vectores para B
245 x_vec = z ( k ) ;
246 y_vec = 0;
247 z_vec = H ( k ) * escala_longitud ;
248 % Coordenadas de los vectores para E

7
249 x_vec_E = z ( k ) ;
250 y_vec_E = 0;
251 z_vec_E = E ( k ) * escala_longitud ;
252

253 % Plotear vectores para B

254 hQuiverB = quiver3 ( x_vec , y_vec , 0 , 0 ,
z_vec , 0 , ’r ’ , ’ MaxHeadSize ’ ,
0.06 , ’ LineWidth ’ , 1.5) ;
255 % Plotear vectores para E
256 hQuiverE = quiver3 ( x_vec_E , y_vec_E , 0 ,
0 , 0 , z_vec_E , ’k ’ , ’ MaxHeadSize ’ ,
0.006 , ’ LineWidth ’ , 1.5) ;
257

258 end
259 hold off ;
260

261 % Ajustar l m i t e s y etiquetas del plot

262 axis ([0 8 -( Emax *0.2) ( Emax *0.2) -( Emax *1.5)
( Emax *1.5) ]) ;
263 xlabel ( ’z ’) ;
264 ylabel ( ’B ( y ) [ ] ’) ;
265 zlabel ( ’E ( x ) ’) ;
266 title ( ’ S I M U L A C I N DE ONDAS
E L E C T R O M A G N T I C A S ’) ;
267 view (30 ,30) ;
268 grid on ;
269 drawnow ; % Actualizar la figura
270

271 % Pausar la e j e c u c i n si el b o t n de pausa

est presionado
272 if getappdata ( hStopButton , ’ stop ’)
273 break ;
274 end
275 end
276

277 function resultado =

m u l t i p l i c a r H a s t a U n a C i f r a ( valor )
278 while valor < 10
279 valor = valor * 10;
280 end
281

282 if valor > 10

283 valor = valor / 10;
284 end
285

286 resultado = valor ;

8
287 return ;
288 end
289

290 function resultado = valorDeAjuste ( valor )

291 res =0;
292 while valor < 10
293 valor = valor * 10;
294 res = res + 1;
295 end
296

297 if valor > 10

298 res = res - 1;
299 end
300

301 resultado = res ;

302 return ;
303 end
304

305 % F u n c i n de callback para el b o t n de pausa

306 function stopSimulation ( hObject , ~)
307 setappdata ( hObject , ’ stop ’ , true ) ;
308 end
309

310 % F u n c i n de callback para el checkbox de

mostrar ondas
311 function toggleWaves ( hObject , ~)
312 if get ( hObject , ’ Value ’)
313 set ( hPlotB , ’ Visible ’ , ’ on ’) ;
314 set ( hPlotE , ’ Visible ’ , ’ on ’) ;
315 set ( hQuiverB , ’ Visible ’ , ’ on ’) ;
316 set ( hQuiverE , ’ Visible ’ , ’ on ’) ;
317 else
318 set ( hPlotB , ’ Visible ’ , ’ off ’) ;
319 set ( hPlotE , ’ Visible ’ , ’ off ’) ;
320 set ( hQuiverB , ’ Visible ’ , ’ off ’) ;
321 set ( hQuiverE , ’ Visible ’ , ’ off ’) ;
322 end
323 end
324 end
Listing 1: Codigo completo de la Simulacion

9
 Explicacion del Código
1 f_real = input ( ’ Ingrese el valor de la frecuencia
( f ) : ’) ;
2

3 if isempty ( f_real ) || f_real <= 0

4 disp ( ’ No se i n g r e s n i n g n valor o el valor es
i n v l i d o , se t o m a r 50 como valor . ’) ;
5 f_real = 50;
6 end
Listing 2: Registro del valor de la frecuencia

Explicación: Este segmento de código solicita al usuario que ingrese el valor

de la frecuencia (f real). Si el usuario no proporciona ningún valor o el valor
ingresado es negativo, se establece un valor predeterminado de 50.
1 HSimulado = Hmax * 10;
Listing 3: Ajustes

Explicación: En este bloque de código se realiza un ajuste especı́fico multipli-

cando el valor de Hmax por 10 para obtener HSimulado.
1 valZoom = input ( ’ Ingrese el acercamiento del 1 -5 , 1
es cerca , no ingrese otro tipo de valores ’) ;
2

3 if isempty ( valZoom )
4 disp ( ’ El valor ingresado no es v l i d o , se
g e n e r a r un valor predeterminado . ’) ;
5 valZoom = 1;
6 end
7

8 auxZoom = 100 * valZoom ;

9 z = linspace (0 , 8 , auxZoom ) ;
10 m = zeros (1 , auxZoom ) ;
Listing 4: Ingreso del acercamiento

Explicación: Aquı́ se solicita al usuario que ingrese un valor de acercamiento

entre 1 y 5. Este valor se utiliza para calcular el espacio z con un cierto espa-
ciado. Si el usuario no proporciona ningún valor o el valor ingresado no está
dentro del rango especificado, se establece un valor predeterminado de 1.
1 for j = 1:0.01:5
2 i = j - 1;
3

4 H = HSimulado .* exp (( -1) .* alfaSimulado .* z )

.* cos ( w .* i - betaSimulado .* z ) ;

10
5 E = Emax .* exp (( -1) .* alfaSimulado .* z ) .*
cos ( w .* i - betaSimulado .* z - theta ) ;
6

7 % Plotear campos H y E y ajustar v i s u a l i z a c i n

a q u ...
8 end
Listing 5: Loop de la simulación

Explicación: Este segmento contiene el bucle principal de la simulación. Cal-

cula los campos magnéticos (H) y eléctricos (E) en función de la posición (z), el
tiempo (i) y otros parámetros. Luego, plotea los campos y actualiza la visual-
ización en cada iteración del bucle.
1 function resultado = m u l t i p l i c a r H a s t a U n a C i f r a ( valor )
2 while valor < 10
3 valor = valor * 10;
4 end
5

6 if valor > 10
7 valor = valor / 10;
8 end
9

10 resultado = valor ;
11 end
12

13 function resultado = valorDeAjuste ( valor )

14 res = 0;
15 while valor < 10
16 valor = valor * 10;
17 res = res + 1;
18 end
19

20 if valor > 10
21 res = res - 1;
22 end
23

24 resultado = res ;
25 end
Listing 6: Funciones Auxiliares

Explicación: Estas son funciones definidas dentro del código que realizan
cálculos auxiliares. La función multiplicarHastaUnaCifra() ajusta un valor
hasta que es mayor o igual a 10, mientras que la función valorDeAjuste() cal-
cula cuántas veces es necesario multiplicar un valor para que sea mayor o igual
a 10.

11
Funcionamiento de la Simulación
La simulación de ondas electromagnéticas se basa en la resolución numérica de
las ecuaciones fundamentales del electromagnetismo, conocidas como las ecua-
ciones de Maxwell. Estas ecuaciones describen cómo los campos eléctricos (E)
y magnéticos (H) interactúan en un medio dado, como el vacı́o o un mate-
rial dieléctrico. En esta simulación, se calculan los campos E y H en función
de la posición (z), el tiempo (t), y los parámetros fı́sicos del medio, como la
permitividad (ϵ) y la permeabilidad (µ). Luego, se plotean estos campos en
función del espacio y el tiempo para visualizar la propagación de las ondas
electromagnéticas.
La simulación también puede incluir fenómenos como la absorción, dis-
persión, y reflexión de las ondas, lo que permite estudiar cómo se comportan en
diferentes condiciones y materiales.

Codigo Desarrollado
Estructura Modular
El código está organizado en funciones y segmentos de código claramente definidos,
lo que facilita la comprensión y la modificación de cada parte por separado. Por
ejemplo, las funciones auxiliares como multiplicarHastaUnaCifra y valorDeAjuste
se utilizan para realizar cálculos especı́ficos, lo que mejora la legibilidad y la
mantenibilidad del código.

Interactividad
El código solicita al usuario varios datos de entrada mediante la función input,
lo que lo hace interactivo y adaptable a diferentes situaciones. Esto permite
al usuario ajustar los parámetros de la simulación según sea necesario antes de
ejecutarla.

Visualización en Tiempo Real

Durante la simulación, los campos eléctricos y magnéticos se representan gráficamente
en función del espacio y el tiempo, lo que proporciona una visualización en
tiempo real del comportamiento de las ondas electromagnéticas. Esto facilita la
comprensión de los fenómenos fı́sicos subyacentes y permite realizar ajustes en
tiempo real si es necesario.

Flexibilidad de Configuración
El código incluye ajustes y configuraciones que permiten al usuario personalizar
varios aspectos de la simulación, como la frecuencia, la magnitud del campo
eléctrico, el espaciado entre vectores, entre otros. Esto proporciona flexibilidad
para explorar diferentes escenarios y condiciones de simulación.

12
Documentación y Comentarios
El código está acompañado de comentarios detallados que explican cada parte
del código y su funcionalidad. Esto facilita la comprensión del código para otros
usuarios y permite realizar modificaciones o mejoras en el futuro de manera más
eficiente.

13