Diagrama de aljaba en Matplotlib

El diagrama de carcaj es básicamente un tipo de diagrama 2D que muestra líneas vectoriales como flechas. Este tipo de gráficos son útiles en ingenieros eléctricos para visualizar el potencial eléctrico y mostrar gradientes de tensión en ingeniería mecánica.
 

Creación de un diagrama de aljaba

Comencemos a crear un diagrama de carcaj simple que contenga una flecha que explique cómo funciona la función ax.quiver() de Matplotlib. La función ax.quiver() toma cuatro argumentos: 

Sintaxis: 

ax.quiver(x_pos, y_pos, x_dir, y_dir, color) 

Aquí x_pos y y_pos son las posiciones iniciales de la flecha, mientras que x_dir y y_dir son las direcciones de la flecha. 
La siguiente gráfica contiene una flecha de carcaza que comienza en x_pos = 0 y y_pos = 0. La dirección de la flecha apunta hacia arriba y hacia la derecha en x_dir = 1 y y_dir = 1.

Ejemplo:  

# Import libraries
import numpy as np
import matplotlib.pyplot as plt
 
 
# Creating arrow
x_pos = 0
y_pos = 0
x_direct = 1
y_direct = 1
 
# Creating plot
fig, ax = plt.subplots(figsize = (12, 7))
ax.quiver(x_pos, y_pos, x_direct, y_direct)
ax.set_title('Quiver plot with one arrow')
 
# Show plot
plt.show()

Producción : 

Carcaj Parcela con dos flechas

Agreguemos otra flecha al gráfico que pase por dos puntos de inicio y dos direcciones. Manteniendo la flecha original que comienza en el origen (0, 0) y apunta hacia arriba y en la dirección correcta (1, 1), y crea la segunda flecha que comienza en (0, 0) apuntando hacia abajo en la dirección (0, -1) .Para ver claramente el punto inicial y final, estableceremos los límites de los ejes en [-1.5, 1.5] usando el método ax.axis() y pasando los argumentos en forma de [x_min, x_max, y_max, y_min] . Al agregar un argumento adicional scale=value al método ax.quiver(), podemos administrar las longitudes de las flechas para que se vean más largas y se muestren mejor en la gráfica.

Ejemplo:  

# Import libraries
import numpy as np
import matplotlib.pyplot as plt
 
 
# Creating arrow
x_pos = [0, 0]
y_pos = [0, 0]
x_direct = [1, 0]
y_direct = [1, -1]
 
# Creating plot
fig, ax = plt.subplots(figsize = (12, 7))
ax.quiver(x_pos, y_pos, x_direct, y_direct,
         scale = 5)
 
ax.axis([-1.5, 1.5, -1.5, 1.5])
 
# show plot
plt.show()

Producción : 
 

Parcela de aljaba usando meshgrid

Un diagrama de carcaj que contiene dos flechas es un buen comienzo, pero es demasiado lento y demasiado largo para agregar flechas al diagrama de carcaj uno por uno. Entonces, para crear una superficie de flechas completamente 2D, usaremos el método meshgrid() de Numpy. Primero, cree un conjunto de arrays denominadas X e Y que representen las posiciones iniciales de x e y respectivamente de cada flecha en el diagrama de carcaj. Las posiciones iniciales de las flechas x, y también se pueden usar para definir los componentes xey de cada dirección de flecha. En la siguiente gráfica, u y v denotan la array de direcciones de las flechas del carcaj y definiremos la dirección de la flecha en función del punto de inicio de la flecha utilizando las siguientes ecuaciones: 

x_{direction} = cos(x_{starting \ point})
y_{direction} = sin(y_{starting \ point})

Ejemplo:  

# Import libraries
import numpy as np
import matplotlib.pyplot as plt
 
 
# Creating arrow
x = np.arange(0, 2.2, 0.2)
y = np.arange(0, 2.2, 0.2)
 
X, Y = np.meshgrid(x, y)
u = np.cos(X)*Y
v = np.sin(Y)*Y
 
# creating plot
fig, ax = plt.subplots(figsize =(14, 8))
ax.quiver(X, Y, u, v)
 
ax.xaxis.set_ticks([])
ax.yaxis.set_ticks([])
ax.axis([-0.3, 2.3, -0.3, 2.3])
ax.set_aspect('equal')
 
# show plot
plt.show()

Producción : 
 

Carcaj Graficar usando gradiente

Vamos a crear un diagrama de carcaj que muestre la función de gradiente. El método np, gradient() de Numpy se puede usar para aplicar la función de gradiente a la posición inicial x, y de cada flecha. La ecuación se utiliza para crear la siguiente gráfica:

z = xe^{-x^2-y^2}

Ejemplo: 

# Import libraries
import numpy as np
import matplotlib.pyplot as plt
 
 
# Creating arrows
x = np.arange(-2, 2.2, 0.2)
y = np.arange(-2, 2.2, 0.2)
 
# Creating gradient
X, Y = np.meshgrid(x, y)
z = X * np.exp(-X**2-Y**2)
dx, dy = np.gradient(z)
 
# Creating plot
fig, ax = plt.subplots(figsize =(9, 9))
ax.quiver(X, Y, dx, dy)
 
ax.xaxis.set_ticks([])
ax.yaxis.set_ticks([])
ax.set_aspect('equal')
 
# show plot
plt.show()

Producción : 
 

Parcela de carcaj para colorear

El método ax.quiver() de la biblioteca matplotlib de python proporciona un color de atributo opcional que especifica el color de la flecha. El atributo de color del carcaj requiere las mismas dimensiones que las arrays de posición y dirección. 

A continuación se muestra el código que modifica los diagramas de carcaj que hicimos anteriormente:

Ejemplo 1: 

# Import libraries
import numpy as np
import matplotlib.pyplot as plt
 
# Defining subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize =(14, 8))
 
 
# first subplot
# Creating arrows
x = np.arange(0, 2.2, 0.2)
y = np.arange(0, 2.2, 0.2)
X, Y = np.meshgrid(x, y)
u = np.cos(X)*Y
v = np.sin(y)*Y
n = -2
 
# Defining color
color = np.sqrt(((v-n)/2)*2 + ((u-n)/2)*2)
 
# Creating plot
ax1.quiver(X, Y, u, v, color, alpha = 0.8)
ax1.xaxis.set_ticks([])
ax1.yaxis.set_ticks([])
ax1.axis([-0.2, 2.3, -0.2, 2.3])
ax1.set_aspect('equal')
ax1.set_title('meshgrid function')
 
# second subplot
# Creating arrows
x = np.arange(-2, 2.2, 0.2)
y = np.arange(-2, 2.2, 0.2)
X, Y = np.meshgrid(x, y)
z = X * np.exp(-X**2 -Y**2)
dx, dy = np.gradient(z)
n = -2
 
# Defining color
color = np.sqrt(((dx-n)/2)*2 + ((dy-n)/2)*2)
 
# Creating plot
ax2.quiver(X, Y, dx, dy, color)
ax2.xaxis.set_ticks([])
ax2.yaxis.set_ticks([])
ax2.set_aspect('equal')
ax2.set_title('gradient')
 
 
# show figure
plt.tight_layout()
plt.show()

Producción : 
 

Ejemplo 2: Construcción de un diagrama de función de aljaba  que define el campo 2D que tiene cuatro vértices como se muestra en el siguiente diagrama:

# Import libraries
import numpy as np
import matplotlib.pyplot as plt
 
# Creating arrow
x = np.arange(0, 2 * np.pi + 2 * np.pi / 20,
              2 * np.pi / 20)
y = np.arange(0, 2 * np.pi + 2 * np.pi / 20,
              2 * np.pi / 20)
 
X, Y = np.meshgrid(x, y)
 
u = np.sin(X)*np.cos(Y)
v = -np.cos(X)*np.sin(Y)
 
# Defining color
color = np.sqrt(((dx-n)/2)*2 + ((dy-n)/2)*2)
 
# Creating plot
fig, ax = plt.subplots(figsize =(14, 9))
ax.quiver(X, Y, u, v, color, alpha = 1)
 
ax.xaxis.set_ticks([])
ax.yaxis.set_ticks([])
ax.axis([0, 2 * np.pi, 0, 2 * np.pi])
ax.set_aspect('equal')
 
# show plot
plt.show()

Producción :