kgsim 0.3.2__tar.gz → 0.3.4__tar.gz

{kgsim-0.3.2 → kgsim-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kgsim
-Version: 0.3.2
+Version: 0.3.4
 Summary: A library to interact with simulations with.
 Author: Keyan Gootkin
 Author-email: Keyan Gootkin <keyangootkin@gmail.com>

{kgsim-0.3.2 → kgsim-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kgsim"
-version = "0.3.2"
+version = "0.3.4"
 description = "A library to interact with simulations with."
 authors = [
   { name="Keyan Gootkin", email="keyangootkin@gmail.com" },

{kgsim-0.3.2 → kgsim-0.3.4}/src/kgsim/dhybridr/dhybridr.py

@@ -7,11 +7,11 @@ from glob import glob
 from os import system
 from os.path import exists
 from h5py import File as h5File
-from numpy import mean, linspace, diff, exp, array, prod, inf, vstack, nanmin, \
-                  nanmax, append
+from numpy import mean, linspace, diff, exp, array, prod, inf, vstack, nanmin, nanmax, append, \
+    ndarray, arange
 from numpy.random import choice
 
-from kgsim.fields import ScalarField, VectorField, Az
+from kgsim.fields import ScalarField, VectorField, Az, single_point_single_lag_structure_function
 from kgsim.simulation import GenericSimulation, SimulationGroup
 from kgsim.particles import Species, Particle
 from kgsim.dhybridr.io import dHybridRinput, dHybridRout
@@ -22,7 +22,7 @@ from kgsim.templates import dHybridRtemplate
 from kplot import show, func_video
 from kbasic.bar import verbose_bar
 from kbasic.strings import purple
-from kbasic.parsing import Folder
+from kbasic.parsing import Folder, Path, ensure_path
 from kbasic.vectors import Vector
 
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
@@ -35,6 +35,28 @@ track_keys = [
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                                   Functions                                    <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def create_dhybridr_data_file(data: ndarray, path: Path) -> h5File:
+    """docstring"""
+    with h5File(path, 'a') as file:
+        file['DATA'] = data
+        for i,si in enumerate(data.shape):
+            file['AXIS'][f'X{i+1} AXIS'] = [0., si]
+    return file
+
+def save_dhybridr_scalar_field(field: ScalarField, destination: Path):
+    """docstring"""
+    assert exists(destination)
+    assert hasattr(field.parent, 'iters')
+    for f,it in zip(field, field.parent.iters):
+        fn = destination / f'{str(it).zfill(8)}_{field.name}.h5'
+        create_dhybridr_data_file(f, fn)
+
+def save_dhybridr_vector_field(field: VectorField, destination: Path):
+    """docstring"""
+    save_dhybridr_scalar_field(field.x, destination/'x')
+    save_dhybridr_scalar_field(field.y, destination/'y')
+    save_dhybridr_scalar_field(field.z, destination/'z')
+
 # simulation parsing
 def extract_energy(file_name: str) -> tuple:
     """docstring"""
@@ -45,9 +67,13 @@ def extract_energy(file_name: str) -> tuple:
         dlne = diff(lne)[0]
         E = exp(lne)
         return E, fE, dlne
+
+
 def iters(simulation) -> list[int]:
     """Grab the iterations of each snapshot for a simulation"""
     return [int(fn[-11:-3]) for fn in simulation.density.file_names]
+
+
 def times(simulation: GenericSimulation, ndigits: int = 7) -> list[float]:
     """return the time (in simulation units) of each measurement
 
@@ -61,6 +87,8 @@ def times(simulation: GenericSimulation, ndigits: int = 7) -> list[float]:
     """
     x = list(array(iters(simulation)).astype(float) * simulation.dt)
     return [round(xi, ndigits) for xi in x]
+
+
 def particle_video(
     sim,
     particles: list[str] | int,
@@ -139,9 +167,11 @@ class dHybridRparticle(Particle):
         Particle.__init__(self, species=species, tag=tag)
         self.loaded: bool = False
         if load: self.load()
+
     def __len__(self) -> int:
         assert self.loaded, f"Tried to take the length of {self} without loading first"
         return len(self.x)
+
     def load(self):
         """docstring"""
         with h5File(self.species.path) as file:
@@ -158,6 +188,20 @@ class dHybridRparticle(Particle):
             self.B = Vector(self.B1, self.B2, self.B3)
             self.E = Vector(self.E1, self.E2, self.E3)
             self.loaded: bool = True
+
+    def structure_function(self, l):
+        """docstring"""
+        u = abs(self.parent.u)
+        xcells = (self.x // self.parent.dx).astype(int)
+        ycells = (self.y // self.parent.dy).astype(int)
+        pis = arange(len(self.parent)-1) * self.species.pipsi
+        return array([
+            single_point_single_lag_structure_function(
+                xcells[i], ycells[i], 1, u[bi], l
+                ) for i,bi in verbose_bar(zip(pis, range(len(self.parent))), self.parent.verbose)
+            ])
+
+
 class dHybridRspecies(Species):
     def __init__(
         self,
@@ -176,11 +220,15 @@ class dHybridRspecies(Species):
         if self.input.track_dump:
             self.path = parent.path+f"/Output/Tracks/Sp{self.nstr}/track_Sp{self.nstr}.h5"
             self.load()
+
     def __repr__(self) -> str: return self.name
+
     def __str__(self) -> str: return self.name
+
     def __len__(self) -> int:
         assert self.loaded, f"Tried to take the length of {self} without loading first"
         return len(self.tags)
+
     def __getitem__(self, key):
         match key:
             case str(tag): return dHybridRparticle(self, tag)
@@ -193,6 +241,7 @@ class dHybridRspecies(Species):
                         1 if di is None else di
                         )
                     ]
+
     def load(self):
         """docstring"""
         with h5File(self.path) as file:
@@ -209,6 +258,8 @@ class dHybridRspecies(Species):
         ])
         if len(particle_list)==1: return particle_list[0]
         else: return particle_list
+
+
 class dHybridR(GenericSimulation):
     """
     A simulation class to interact with dHybridR simulations in python
@@ -304,11 +355,13 @@ class dHybridR(GenericSimulation):
         self.dy: float = self.input.boxsize[1]/self.input.ncells[1]
         self.dz: float = self.input.boxsize[2]/self.input.ncells[2] \
                          if len(self.input.boxsize)==3 else inf
+
     def run(self, initializer: dHybridRinitializer, submit_script: AnvilSubmitScript) -> None:
         """docstring"""
         initializer.prepare_simulation()
         submit_script.write()
         system(f"sh {submit_script.path}")
+
     def parse_output(self) -> None:
         """docstring"""
         self.out = dHybridRout(self.path+"/out")
@@ -413,6 +466,15 @@ class dHybridR(GenericSimulation):
             self.start = time()
         self.iter = array(iters(self))
         self.time = array(times(self))
+
+    def save_field(self, field: ScalarField | VectorField) -> None:
+        """docstring"""
+        destination = self.output / f"Postfacto/{field.name}"
+        system(f"mkdir -p {destination}")
+        match field:
+            case ScalarField(): save_dhybridr_scalar_field(field, destination)
+            case VectorField(): save_dhybridr_vector_field(field, destination)
+
     def magnetic_potential_extrema(self):
         """docstring"""
         n, x = inf, -inf

{kgsim-0.3.2 → kgsim-0.3.4}/src/kgsim/dhybridr/turbulence.py

@@ -45,28 +45,28 @@ def non_thermal_slope(E, f, mach):
     [slope, b], _ = curve_fit(line, log10(E), log10(f/E))
     return slope, b
 
-def S(p: int, u: ndarray, l: int):
-    """
-    Compute structure function of power p, of field u, at lag l
-    S_p(u, l) = <(u(x) - u(x + l))^p>
-    p: int - order of structure function
-    u: Array - field to take structure function of
-    l: int - lag, i.e. how many pixels away should the function look
-    """
-    (Nx, Ny) = u.shape
-    assert l < min(u.shape), f"l ({l}) is larger than smallest dimension ({min(u.shape)})"
-    grid = mgrid[-Nx//2:Nx//2, -Ny//2:Ny//2]
-    grid = hypot(grid[0], grid[1])
-    grid = where(grid//1 == l, True, False)
-    in_annulus = lambda i, j: roll(grid, (i - Nx//2, j - Ny//2), axis=(0,1))
-    # for some reason this needs to be transposed
-    return array([
-        [
-            mean(
-                (u[i, j] - u[in_annulus(i, j)]) ** p
-            ) for i in arange(Nx)
-        ] for j in progress_bar(arange(Ny))
-    ]).T
+# def S(p: int, u: ndarray, l: int):
+#     """
+#     Compute structure function of power p, of field u, at lag l
+#     S_p(u, l) = <(u(x) - u(x + l))^p>
+#     p: int - order of structure function
+#     u: Array - field to take structure function of
+#     l: int - lag, i.e. how many pixels away should the function look
+#     """
+#     (Nx, Ny) = u.shape
+#     assert l < min(u.shape), f"l ({l}) is larger than smallest dimension ({min(u.shape)})"
+#     grid = mgrid[-Nx//2:Nx//2, -Ny//2:Ny//2]
+#     grid = hypot(grid[0], grid[1])
+#     grid = where(grid//1 == l, True, False)
+#     in_annulus = lambda i, j: roll(grid, (i - Nx//2, j - Ny//2), axis=(0,1))
+#     # for some reason this needs to be transposed
+#     return array([
+#         [
+#             mean(
+#                 (u[i, j] - u[in_annulus(i, j)]) ** p
+#             ) for i in arange(Nx)
+#         ] for j in progress_bar(arange(Ny))
+#     ]).T
 
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                                    Classes                                     <|===|-<

{kgsim-0.3.2 → kgsim-0.3.4}/src/kgsim/fields/__init__.py

@@ -1,3 +1,4 @@
+from kgsim.fields.structure import *
 from kgsim.fields.scalar import *
 from kgsim.fields.vector import *
 from kgsim.fields.calc import *

{kgsim-0.3.2 → kgsim-0.3.4}/src/kgsim/fields/scalar.py

@@ -3,7 +3,6 @@
 # >-|===|>                                    Imports                                     <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 from typing import Optional, Self, Callable
-from glob import glob
 from functools import cached_property
 from os.path import isdir, isfile
 import logging
@@ -63,7 +62,7 @@ class ScalarField:
         caching: bool = False,
         verbose: bool = False,
         debug: bool = False,
-    ) -> None:
+        ) -> None:
         self.name: str = name
         self.latex: str = latex
         self.parent = parent
@@ -82,36 +81,39 @@ class ScalarField:
             #if its a folder
             case Folder() | str() if isdir(source):
                 self.path = Folder(source)
-                self.single = False
                 example_file: File = self.path.children[0]
                 if example_file.extension==".h5": self._from_folder_of_h5(self.path)
             #otherwise its a file
             case File() | str() if isfile(source):
                 self.path = File(source)
-                self.single = True
                 if self.path.extension=="h5": self._from_h5(self.path)
                 else: self._from_csv(self.path)
             #or if its already been read
             case Array():
-                self.single = True
                 self._from_numpy(array(source))
             case _: raise TypeError(f"{source} of wrong type: {type(source)}")
         # read the stats file
         if parent: self.stats = Folder(f"{self.parent.path}/stats")
         if self.stats: self._read_stats()
-    def __len__(self) -> int: return 1 if self.single else len(self.file_names)
+
+    def __len__(self) -> int:
+        if hasattr(self, 'array'):
+            return 1 if len(self.array.shape)==2 else len(self.array)
+        return len(self.file_names)
+
     def __iter__(self) -> Self:
-        assert not self.single, "Cannot iterate through single scalar field"
         self.index = 0
         return self
+
     def __next__(self) -> NDArray:
         if self.index < len(self):
             i = self.index
             self.index += 1
             return self[i]
         else: raise StopIteration
+
     def __getitem__(self, item: int|slice|ArrayLike) -> NDArray:
-        if self.single: return self.array[item]
+        if hasattr(self, 'array'): return self.array[item]
         match item:
             case int():
                 return self.cache[item] if self.caching and item in self.cache \
@@ -132,32 +134,35 @@ class ScalarField:
                 self.cache[i] if self.caching and i in self.cache \
                 else self.reader(self.file_names[i], i) for i in item
             ])
+
     def _from_folder_of_h5(self, path: Folder) -> None:
         self.file_names: list = sorted(self.path.glob("*.h5"))
         self.reader: Callable = self._read_h5_file
         self.shape = self[0].shape
         self.ndims = len(self.shape)
         self.size = prod(self.shape) * len(self)
+
     def _from_h5(self, file:str) -> None:
         self.file = file.path if isinstance(file, File) else file
         self.array = self._read_h5_file(file, 0)
         self.shape = self.array.shape
         self.ndims = len(self.shape)
         self.size = prod(self.shape) * len(self)
+
     def _read_h5_file(self, file:str, item) -> NDArray:
         with h5File(file, 'r') as f:
             output = array(f["DATA"][:])
             #GODDMANIT I HATE THAT IT DOES Y,X and not X,Y
             if self.caching: self.cache[item] = output
             return output
-    def _from_csv(self, source) -> None:
-        ...
+
     def _read_csv_file(self, file:str) -> None: pass
+
     def _from_numpy(self, arr:ndarray) -> None:
-        self.single = True
         self.array = arr
         self.shape = arr.shape
         self.ndims = len(self.shape)
+
     def _read_stats(self) -> None:
         ensure_path(self.stats.path)
         self.statsFile = File(f"{self.stats.path}/{self.name}.csv")
@@ -187,6 +192,7 @@ class ScalarField:
             self.min = nanmin(data[0])
             self.max = nanmax(data[1])
             savetxt(self.statsFile.path, data, delimiter=',', header="min,max,median,mean,std")
+
     @cached_property #cached property only is used if self.min not set by stats file
     def min(self) -> Number:
         """docstring"""
@@ -195,6 +201,7 @@ class ScalarField:
             y = append(frame, x)
             x = nanmin(y)
         return x
+
     @cached_property #cached property only is used if self.max not set by stats file
     def max(self) -> Number:
         """docstring"""
@@ -203,17 +210,20 @@ class ScalarField:
             y = append(frame, x)
             x = nanmax(y)
         return x
+
     @cached_property
     def extrema(self) -> tuple[Number]:
         """docstring"""
         return self.min, self.max
+
     def show(self, item:int, **kwargs) -> None:
         """docstring"""
         if hasattr(self.parent, 'dx'):
             x_ticks = arange(0, self.parent.input.boxsize[0], self.parent.dx)
             y_ticks = arange(0, self.parent.input.boxsize[1], self.parent.dy)
-            show(self[item], x=x_ticks, y=y_ticks, **kwargs)
+            return show(self[item], x=x_ticks, y=y_ticks, **kwargs)
         assert False
+
     def movie(self, file_name=None, norm='none', cmap=default_cmap, func=None,**kwds) -> None:
         """docstring"""
         show_video(

kgsim-0.3.4/src/kgsim/fields/structure.py

@@ -0,0 +1,161 @@
+"""calculate the structure function of arrays and fields"""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                    Imports                                     <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from math import sqrt
+from collections.abc import Iterable
+from kbasic import verbose_bar, Tex
+from numpy import ndarray, array, mgrid, random, floor_divide, hypot, where, roll, interp, log10, \
+    argsort
+from numpy import abs as npabs
+from numpy import mean as npmean
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                   Functions                                    <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def select_random_pixels(image: ndarray, fill_fraction):
+    """select fill_fraction of pixels of image randomly"""
+    (Nx, Ny) = image.shape
+    if fill_fraction==1:
+        X2D, Y2D = mgrid[:Nx, :Ny]
+        x, y = X2D.flatten(), Y2D.flatten()
+        return x, y
+    pixel_numbers = random.choice(
+        image.size,
+        size=int((image.size*fill_fraction)//1),
+        replace=False
+    )
+    x = floor_divide(pixel_numbers, Nx)
+    y = pixel_numbers % Nx
+    return x, y
+
+def single_point_single_lag_structure_function(i, j, p, u, l):
+    """docstring"""
+    (Nx, Ny) = u.shape
+    # prepare annulus selection function
+    grid = mgrid[-Nx//2:Nx//2, -Ny//2:Ny//2]
+    grid = hypot(grid[0], grid[1])
+    grid = where(grid//1 == l, True, False)
+    in_annulus = lambda i, j: roll(grid, (i - Nx//2, j - Ny//2), axis=(0,1))
+    return npmean(npabs(u[i,j] - u[in_annulus(i,j)])**p)
+
+def single_structure_function(p, u, l, sample, verbose, _is_multi: bool = False):
+    """
+    for a single value of l, return the structure function
+
+    Args:
+        p (int): structure function order
+        u (ndarray): the field to compute the structure function for
+        l (int): lag
+        sample (str|float): 'all' if you want to sample every point else the fraction 
+            of possible points to select
+        verbose (bool): whether to provide verbose output
+
+    Returns:
+        ndarray: The p^th order structure function of u with lag l
+    """
+    (Nx, Ny) = u.shape
+    # select the pixels to calculate the structure function for
+    x_selected, y_selected = select_random_pixels(u, 1 if sample=='all' else sample)
+    # prepare annulus selection function
+    grid = mgrid[-Nx//2:Nx//2, -Ny//2:Ny//2]
+    grid = hypot(grid[0], grid[1])
+    grid = where(grid//1 == l, True, False)
+    in_annulus = lambda i, j: roll(grid, (i - Nx//2, j - Ny//2), axis=(0,1))
+    if sample=='all':
+        return array([
+            # for pixel i,j
+            npmean(
+                # take the mean of |u_ij - u_annulus|^p for all values of u in the annulus
+                npabs(u[i, j] - u[in_annulus(i, j)]) ** p
+            ) for i,j in verbose_bar(zip(x_selected, y_selected), verbose, total=len(x_selected))
+        ]).reshape(u.shape)
+    br = verbose_bar(
+        zip(x_selected, y_selected),
+        verbose,
+        desc=Tex(rf"calculate \mathcal[S]^{p}(\ell={l})").string,
+        total=len(x_selected),
+        position=1,
+        leave=False
+    )
+    # take the mean of |u_ij - u_annulus|^p for all selected pixels
+    return npmean(array([
+            npmean(
+                npabs(u[i, j] - u[in_annulus(i, j)]) ** p
+            ) for i,j in br
+        ]))
+
+def S(
+        p: int,
+        u: ndarray,
+        l: int|ndarray|list,
+        sample: str|float = "all",
+        verbose: bool = True
+):
+    """structure function factory
+
+    Args:
+        p (int): _description_
+        u (ndarray): _description_
+        l (int | ndarray | list): _description_
+        sample (str | float, optional): _description_. Defaults to "all".
+        verbose (bool, optional): _description_. Defaults to True.
+
+    Returns:
+        _type_: _description_
+    """
+    match l:
+        # if l is a single number
+        case int(): return single_structure_function(p,u,l,sample,verbose)
+        # if we want to calculate a series of l's
+        case Iterable():
+            lbar = verbose_bar(l, verbose, total=len(l), position=0)
+            return array([
+                single_structure_function(p,u,li,sample,False,_is_multi=True) for li in lbar
+            ])
+
+def log_interp(x_interp, x, y):
+    """perform interpolation in logspace"""
+    return 10**interp(log10(x_interp), log10(x), log10(y))
+
+def sonic_scale(u, sample=0.01, tolerance=0.05, Ntries=10, return_spectrum=False, verbose=True):
+    """compute the lag at which S(1, u, l)=1"""
+    du = lambda li: S(1, u, li, verbose=False, sample=sample)
+
+    left = 1
+    Sl = du(left)
+    right = int(max(u.shape)//sqrt(2))
+    Sr = du(right)
+    assert Sl < 1 and Sr > 1, f"Sonic point {'above' if Sr < 1 else 'below'} inertial range of \
+        {left}-{right} and {Sl}-{Sr}."
+
+    guess = int(log_interp(1, [Sl, Sr], [left, right])//1)
+    Sg = du(guess)
+    Ng = 0
+
+    all_l, all_s = [left, guess, right], [Sl, Sg, Sr]
+
+    while npabs(Sg-1) > tolerance:
+        if Sg>1:
+            Sr=Sg
+            right=guess
+        else:
+            Sl=Sg
+            left=guess
+
+        if left-right==1:
+            if verbose: print("didn't hit tolerance, but guess range is 1")
+            break
+        guess = int(log_interp(1, [Sl, Sr], [left, right])//1)
+        all_l.append(guess)
+        Sg = du(guess)
+        all_s.append(Sg)
+        Ng+=1
+        if Ng>=Ntries:
+            if verbose: print(f"didn't hit tolerance of {tolerance} in {Ntries} tries")
+            if verbose: print(f"S({guess})={Sg}")
+            break
+    if return_spectrum:
+        sort = argsort(all_l)
+        return guess, array(all_l)[sort], array(all_s)[sort]
+    return guess

{kgsim-0.3.2 → kgsim-0.3.4}/src/kgsim/fields/vector.py

@@ -64,13 +64,15 @@ class VectorField:
         self.caching = caching
         # set self.components, self.ndims, self.size
         self._parse_components(components)
+
     def __len__(self) -> int: return min([len(c) for c in self.components])
+
     def __abs__(self) -> NDArray | ScalarField:
         if hasattr(self, 'magnitude'):
-            return self.magnitude
-        if (p:=self.path / "Intensity").exists:
+            return getattr(self, 'magnitude')
+        if type(p:=self.path / "Intensity")==Folder:
             self.magnitude = ScalarField(
-                p, 
+                p,
                 name=self.name+'_magnitude',
                 latex=f"$|{self.latex}|$",
                 parent=self.parent,
@@ -79,8 +81,9 @@ class VectorField:
                 debug=self.debug
             )
             return self.magnitude
+        self.magnitude = _vector_mag(self)
+        return self.magnitude
 
-        return _vector_mag(self)
     def __getitem__(self, item: int|slice) -> NDArray:
         match type(item):
             case int(): return array([c[item] for c in self.components])
@@ -97,6 +100,7 @@ class VectorField:
                         c[i] for c in self.components
                     ] for i in item_iters
                 ])
+
     def _parse_components(self, source: tuple) -> None:
         """
         Parse user input components into class attributes
@@ -153,6 +157,7 @@ class VectorField:
                 for j in range(other.shape[1])] 
             for k in verbose_bar(range(len(other)), self.verbose, desc="constructing B...")])
             return sum(A * B, axis=2)
+
     def cross(self, other: Self, k:int) -> NDArray:
         if type(other)==VectorField: 
             assert self.ndims==3, "only 3D vector fields can be crossed at this time"
@@ -162,11 +167,13 @@ class VectorField:
                 self.z[k]*other.x[k] - self.x[k]*other.z[k],
                 self.x[k]*other.y[k] - self.y[k]*other.x[k]
             ])
+
     @cached_property
     def potential(self) -> NDArray:
         match len(self.x.shape):
             case 2: 
                 return array([Az(self.x[i], self.y[i], dx=self.dx, dy=self.dy) for i in range(len(self))])
+
     def calc_perp(self, item=None) -> NDArray: 
         if not item:
             self.perp = array([
@@ -185,6 +192,7 @@ class VectorField:
             ]
             self.perp = array([hypot(self.perpendicular[0][j], self.perpendicular[1][j]) for j in item_iters])
         else: raise TypeError(f"calc_perp only takes ints, slices, or None for item, not {type(item)}-type objects")
+
     def set_parallel(self, component:str) -> None:
         match component.lower():
             case 'x':
@@ -196,6 +204,7 @@ class VectorField:
             case 'z':
                 self.parallel = None if not hasattr(self, 'z') else self.z
                 self.perpendicular = self.x, self.y
+
     def movie(self, mode='mag', norm='none', cmap=default_cmap, **kwrg) -> None:
         match mode.lower():
             case 'mag'|'magnitude'|'abs':
@@ -214,6 +223,7 @@ class VectorField:
                 )
                 def reveal_thyself(s, **kwargs): return array([self.parallel[i] for i in range(len(self))])
         reveal_thyself(self if self.parent is None else self.parent, **kwrg)
+
     def quiver(
         self,
         ind: int,
@@ -225,7 +235,7 @@ class VectorField:
         transpose: bool = False,
         #everything else goes into matplotlib command
         **kwargs
-    ) -> None:
+        ) -> None:
         if not ax: ax = gca()
         match x, y:
             case None, None: