nf2 0.3__py3-none-any.whl

nf2/convert/convert_series.py

@@ -0,0 +1,64 @@
+import argparse
+import glob
+import os.path
+
+from tqdm import tqdm
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert NF2 file to VTK.')
+    parser.add_argument('--nf2_dir', type=str, help='path to the source NF2 files', nargs='+', required=True)
+    parser.add_argument('--out_dir', type=str, help='path to the target VTK directory', required=False, default=None)
+    parser.add_argument('--Mm_per_pixel', type=float, help='spatial resolution (0.36 for original HMI)', required=False,
+                        default=None)
+    parser.add_argument('--height_range', type=float, nargs=2, help='height range in Mm', required=False, default=None)
+    parser.add_argument('--metrics', type=str, nargs='*', help='metrics to be computed', required=False, default=['j'])
+    parser.add_argument('--type', type=str, help='type of the conversion (vtk, hdf5, npy, fits)', required=False,
+                        default='vtk')
+    parser.add_argument('--overwrite', action='store_true', help='overwrite existing files', required=False,
+                        default=False)
+
+    args = parser.parse_args()
+
+    nf2_dir = args.nf2_dir if isinstance(args.nf2_dir, list) else [args.nf2_dir]
+    nf2_paths = [sorted(glob.glob(f)) for f in nf2_dir]
+    nf2_paths = [f for files in nf2_paths for f in files]  # flatten list
+
+    Mm_per_pixel = args.Mm_per_pixel
+    out_dir = args.out_dir if args.out_dir is not None else os.path.dirname(nf2_dir[0])
+    os.makedirs(out_dir, exist_ok=True)
+    height_range = args.height_range
+    metrics = args.metrics
+
+    conversion_type = args.type
+    if conversion_type == 'vtk':
+        d_type = '.vtk'
+        from nf2.convert import nf2_to_vtk
+        convert_f = nf2_to_vtk.convert
+    elif conversion_type == 'hdf5':
+        d_type = '.hdf5'
+        from nf2.convert import nf2_to_hdf5
+        convert_f = nf2_to_hdf5.convert
+    elif conversion_type == 'npy':
+        d_type = '.npy'
+        from nf2.convert import nf2_to_npy
+        convert_f = nf2_to_npy.convert
+    elif conversion_type == 'fits':
+        d_type = '.fits'
+        from nf2.convert import nf2_to_fits
+        convert_f = nf2_to_fits.convert
+    else:
+        raise ValueError(f'Unknown conversion type: {conversion_type}')
+
+    for nf2_path in tqdm(nf2_paths, desc='Converting', unit='file'):
+        out_file = os.path.join(out_dir, os.path.basename(nf2_path).replace('.nf2', d_type))
+        if os.path.exists(out_file) and not args.overwrite:
+            print(f'File exists: {out_file}')
+            continue
+        convert_f(nf2_path=nf2_path, out_path=out_file,
+                  Mm_per_pixel=Mm_per_pixel, height_range=height_range, metrics=metrics,
+                  progress=False)
+
+
+if __name__ == '__main__':
+    main()

nf2/convert/muram_to_vtk.py

@@ -0,0 +1,33 @@
+import argparse
+
+import numpy as np
+from astropy import constants as const
+from astropy import units as u
+
+from nf2.evaluation.metric import curl
+from nf2.evaluation.vtk import save_vtk
+from nf2.loader.muram import MURaMSnapshot
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert NF2 file to VTK.')
+    parser.add_argument('--source_path', type=str, help='path to the MURaM simulation.')
+    parser.add_argument('--iteration', type=int, help='iteration of the snapshot.')
+    parser.add_argument('--vtk_path', type=str, help='path to the target VTK file', required=False, default=None)
+    parser.add_argument('--Mm_per_pixel', type=float, help='spatial resolution (needs to be a multiple of 0.192)',
+                        required=False, default=0.192 * 4)
+    parser.add_argument('--height', type=float, help='height of the snapshot', required=False, default=None)
+    args = parser.parse_args()
+
+    snapshot = MURaMSnapshot(args.source_path, args.iteration)
+    muram_cube = snapshot.load_cube(args.Mm_per_pixel * u.Mm / u.pix, target_tau=1.0, height=args.height * u.Mm)
+    b = muram_cube['B']
+    j = curl(b) * u.G / (args.Mm_per_pixel * u.Mm) * const.c / (4 * np.pi)  # Mm_per_pixel
+    j = j.to(u.G / u.s)
+
+    save_vtk(args.vtk_path, vectors={'b': b, 'j': j.value},
+             scalars={'tau': muram_cube['tau']}, Mm_per_pix=args.Mm_per_pixel)
+
+
+if __name__ == '__main__':
+    main()

nf2/convert/nf2_to_fits.py

@@ -0,0 +1,45 @@
+import argparse
+import os
+
+from astropy.io import fits
+
+from nf2.evaluation.output import CartesianOutput
+
+
+def convert(nf2_path, out_path=None, Mm_per_pixel=None, height_range=None, **kwargs):
+    out_path = out_path if out_path is not None \
+        else os.path.join(os.path.dirname(nf2_path), nf2_path.split(os.sep)[-2] + '.hdf5')
+
+    nf2_out = CartesianOutput(nf2_path)
+    output = nf2_out.load_cube(Mm_per_pixel=Mm_per_pixel, height_range=height_range, **kwargs)
+
+    b = output['b']
+    j = output['j']
+
+    header = {'Mm_per_pix': output['Mm_per_pixel'],
+              'data': nf2_out.data_config,
+              'wcs': nf2_out.wcs,
+              'DATE_OBS': nf2_out.time}
+
+    b_hdu = fits.PrimaryHDU(b, header=header)
+    j_hdu = fits.FitsHDU(j)
+    hdul = fits.HDUList([b_hdu, j_hdu])
+    hdul.writeto(out_path)
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert NF2 file to fits.')
+    parser.add_argument('nf2_path', type=str, help='path to the source NF2 file')
+    parser.add_argument('--out_path', type=str, help='path to the target numpy file', required=False, default=None)
+    parser.add_argument('--strides', type=int, help='downsampling of the volume', required=False, default=1)
+
+    args = parser.parse_args()
+    nf2_path = args.nf2_path
+    strides = args.strides
+    out_path = args.out_path
+
+    convert(nf2_path, out_path, strides)
+
+
+if __name__ == '__main__':
+    main()

nf2/convert/nf2_to_hdf5.py

@@ -0,0 +1,62 @@
+import argparse
+import os.path
+from threading import Thread
+
+import h5py
+
+from nf2.evaluation.output import CartesianOutput
+
+
+class _SaveFileTask(Thread):
+
+    def __init__(self, out_path, output, nf2_out):
+        super().__init__()
+        self.out_path = out_path
+        self.output = output
+        self.nf2_out = nf2_out
+
+    def run(self):
+        f = h5py.File(self.out_path, 'w')
+        f.create_dataset('B', data=self.output['b'], dtype='f4', compression='gzip')
+        f.attrs['INFO'] = f'Magnetic vector field (B_x, B_y, B_z): {self.output["b"].shape} (x, y, z, 3)'
+        f.attrs['Mm_per_pixel'] = self.output['Mm_per_pixel']
+        f.attrs['type'] = self.nf2_out.data_config['type']
+        f.attrs['wcs'] = self.nf2_out.wcs[0].to_header_string()
+        f.attrs['time'] = self.nf2_out.time.isoformat('T', timespec='seconds')
+        f.close()
+        print('File saved:', self.out_path)
+
+
+def convert(nf2_path, out_path=None, Mm_per_pixel=None, height_range=None, **kwargs):
+    out_path = out_path if out_path is not None \
+        else os.path.join(os.path.dirname(nf2_path), nf2_path.split(os.sep)[-2] + '.hdf5')
+
+    nf2_out = CartesianOutput(nf2_path)
+    output = nf2_out.load_cube(Mm_per_pixel=Mm_per_pixel, height_range=height_range, **kwargs)
+
+    # save file in background
+    task = _SaveFileTask(out_path, output, nf2_out)
+    task.start()
+    return task
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert NF2 file to VTK.')
+    parser.add_argument('--nf2_path', type=str, help='path to the source NF2 file')
+    parser.add_argument('--out_path', type=str, help='path to the target HDF5 file', required=False, default=None)
+    parser.add_argument('--Mm_per_pixel', type=float, help='spatial resolution (0.36 for original HMI)', required=False,
+                        default=None)
+    parser.add_argument('--height_range', type=float, nargs=2, help='height range in Mm', required=False, default=None)
+
+    args = parser.parse_args()
+    nf2_path = args.nf2_path
+
+    Mm_per_pixel = args.Mm_per_pixel
+    out_path = args.out_path
+    height_range = args.height_range
+
+    convert(nf2_path, out_path, Mm_per_pixel, height_range)
+
+
+if __name__ == '__main__':
+    main()

nf2/convert/nf2_to_npy.py

@@ -0,0 +1,37 @@
+import argparse
+import os.path
+
+import numpy as np
+
+from nf2.evaluation.output import CartesianOutput
+
+
+def convert(nf2_path, out_path=None, Mm_per_pixel=None, height_range=None, **kwargs):
+    out_path = out_path if out_path is not None \
+        else os.path.join(os.path.dirname(nf2_path), nf2_path.split(os.sep)[-2] + '.npy')
+
+    nf2_out = CartesianOutput(nf2_path)
+    output = nf2_out.load_cube(Mm_per_pixel=Mm_per_pixel, height_range=height_range, **kwargs)
+    np.save(out_path, output['b'])
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert NF2 file to VTK.')
+    parser.add_argument('--nf2_path', type=str, help='path to the source NF2 file')
+    parser.add_argument('--out_path', type=str, help='path to the target NPY file', required=False, default=None)
+    parser.add_argument('--Mm_per_pixel', type=float, help='spatial resolution (0.36 for original HMI)', required=False,
+                        default=None)
+    parser.add_argument('--height_range', type=float, nargs=2, help='height range in Mm', required=False, default=None)
+
+    args = parser.parse_args()
+    nf2_path = args.nf2_path
+
+    Mm_per_pixel = args.Mm_per_pixel
+    out_path = args.out_path
+    height_range = args.height_range
+
+    convert(nf2_path, out_path, Mm_per_pixel, height_range)
+
+
+if __name__ == '__main__':
+    main()

nf2/convert/nf2_to_vtk.py

@@ -0,0 +1,62 @@
+import argparse
+import os.path
+from threading import Thread
+
+from nf2.evaluation.output import CartesianOutput
+from nf2.evaluation.vtk import save_vtk
+
+
+class _SaveFileTask(Thread):
+
+    def __init__(self, out_path, output, metrics):
+        super().__init__()
+        self.out_path = out_path
+        self.output = output
+        self.metrics = metrics if metrics is not None else []
+
+    def run(self):
+        Mm_per_pixel = self.output['Mm_per_pixel']
+
+        # split output into vectors and scalars
+        vectors = {k: v for k, v in self.output['metrics'].items() if len(v.shape) == 4 and v.shape[-1] == 3}
+        scalars = {k: v for k, v in self.output['metrics'].items() if len(v.shape) == 3}
+
+        vectors['b'] = self.output['b']
+
+        save_vtk(self.out_path, vectors=vectors, scalars=scalars, Mm_per_pix=Mm_per_pixel)
+
+
+def convert(nf2_path, out_path=None, Mm_per_pixel=None, height_range=None, metrics=None, **kwargs):
+    out_path = out_path if out_path is not None \
+        else os.path.join(os.path.dirname(nf2_path), nf2_path.split(os.sep)[-2] + '.vtk')
+
+    nf2_out = CartesianOutput(nf2_path)
+    output = nf2_out.load_cube(Mm_per_pixel=Mm_per_pixel, height_range=height_range, metrics=metrics, **kwargs)
+
+    # save file in background
+    task = _SaveFileTask(out_path, output, metrics)
+    task.start()
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert NF2 file to VTK.')
+    parser.add_argument('--nf2_path', type=str, help='path to the source NF2 file')
+    parser.add_argument('--out_path', type=str, help='path to the target VTK file', required=False, default=None)
+    parser.add_argument('--Mm_per_pixel', type=float, help='spatial resolution (0.36 for original HMI)', required=False,
+                        default=None)
+    parser.add_argument('--height_range', type=float, nargs=2, help='height range in Mm', required=False, default=None)
+    parser.add_argument('--metrics', type=str, nargs='*', help='metrics to be computed', required=False, default=['j'])
+
+    args = parser.parse_args()
+    nf2_path = args.nf2_path
+
+    Mm_per_pixel = args.Mm_per_pixel
+    out_path = args.out_path
+    height_range = args.height_range
+    metrics = args.metrics
+
+    convert(nf2_path, out_path, Mm_per_pixel, height_range, metrics=metrics, progress=True)
+
+
+if __name__ == '__main__':
+    main()

nf2/convert/nf2_to_vtk_spherical.py

@@ -0,0 +1,51 @@
+import argparse
+import os
+
+import numpy as np
+from astropy import units as u
+
+from nf2.evaluation.output import SphericalOutput
+from nf2.evaluation.output_metrics import current_density, alpha
+from nf2.evaluation.vtk import save_vtk
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Convert NF2 file to VTK.')
+    parser.add_argument('--nf2_path', type=str, help='path to the source NF2 file')
+    parser.add_argument('--out_path', type=str, help='path to the target VTK files', required=False, default=None)
+    parser.add_argument('--overwrite', action='store_true', help='overwrite existing files')
+
+    parser.add_argument('--radius_range', nargs='+', type=float, default=(0.999, 1.3), required=False)
+    parser.add_argument('--latitude_range', nargs='+', type=float, default=(0, 180), required=False)
+    parser.add_argument('--longitude_range', nargs='+', type=float, default=(0, 360), required=False)
+    parser.add_argument('--radians', action='store_true', help='latitude and longitude in radians', required=False,
+                        default=False)
+    parser.add_argument('--pixels_per_solRad', type=int, default=64, required=False)
+
+    args = parser.parse_args()
+    nf2_path = args.nf2_path
+    out_path = nf2_path.replace('.nf2', '.vtk') if args.out_path is None else args.out_path
+
+    radius_range = tuple(args.radius_range) * u.solRad
+    if args.radians:
+        latitude_range = tuple(args.latitude_range) * u.rad
+        longitude_range = tuple(args.longitude_range) * u.rad
+    else:
+        latitude_range = tuple(args.latitude_range) * u.deg
+        longitude_range = tuple(args.longitude_range) * u.deg
+    pixels_per_solRad = args.pixels_per_solRad * u.pix / u.solRad
+
+    assert len(radius_range) == 2, 'radius_range must be a tuple of length 2'
+    assert len(latitude_range) == 2, 'latitude_range must be a tuple of length 2'
+    assert len(longitude_range) == 2, 'longitude_range must be a tuple of length 2'
+
+    output = SphericalOutput(nf2_path)
+    result = output.load(radius_range, latitude_range, longitude_range, pixels_per_solRad, progress=True,
+                         metrics={'j': current_density, 'alpha': alpha})
+
+    vectors = {'B': result['b'], 'B_rtp': result['b_rtp']}
+    radius = result['spherical_coords'][..., 0]
+    metrics = result['metrics']
+    scalars = {'radius': radius, 'current_density': np.sum(metrics['j'] ** 2, -1) ** 0.5, 'alpha': metrics['alpha']}
+    coords = result['coords']
+
+    save_vtk(out_path, coords, vectors, scalars)

nf2/convert/potential_vtk.py

@@ -0,0 +1,118 @@
+import argparse
+import os
+
+import numpy as np
+import pfsspy
+import torch
+from astropy import units as u
+from astropy.coordinates import SkyCoord
+from matplotlib import pyplot as plt
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+from sunpy.map import Map
+
+from nf2.data.util import cartesian_to_spherical, spherical_to_cartesian, vector_spherical_to_cartesian
+from nf2.evaluation.vtk import save_vtk
+
+parser = argparse.ArgumentParser(description='Convert NF2 file to VTK.')
+parser.add_argument('--Br', type=str, help='path to the source radial magnetic field file (full disk map)')
+parser.add_argument('--synoptic', type=str, help='path to the source radial magnetic field file (synoptic map)')
+parser.add_argument('--out_path', type=str, help='path to the target VTK files')
+
+parser.add_argument('--radius_range', nargs='+', type=float, default=(0.999, 1.5), required=False)
+parser.add_argument('--latitude_range', nargs='+', type=float, default=(0 * np.pi, 1 * np.pi), required=False)
+parser.add_argument('--longitude_range', nargs='+', type=float, default=(0 * np.pi, 2 * np.pi), required=False)
+parser.add_argument('--pixels_per_solRad', type=int, default=64, required=False)
+
+args = parser.parse_args()
+out_path = args.out_path
+
+os.makedirs(out_path, exist_ok=True)
+
+radius_range = tuple(args.radius_range)
+latitude_range = tuple(args.latitude_range)
+longitude_range = tuple(args.longitude_range)
+pixels_per_solRad = args.pixels_per_solRad
+
+assert len(radius_range) == 2, 'radius_range must be a tuple of length 2'
+assert len(latitude_range) == 2, 'latitude_range must be a tuple of length 2'
+assert len(longitude_range) == 2, 'longitude_range must be a tuple of length 2'
+
+device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
+
+synoptic_map_br = Map(args.synoptic)
+synoptic_map_br = synoptic_map_br.resample([360 * 2, 180 * 2] * u.pix)
+
+mag_r_map = Map(args.Br)
+mag_r_map = mag_r_map.reproject_to(synoptic_map_br.wcs)
+
+nan_mask = ~np.isnan(mag_r_map.data)
+synoptic_map_br.data[nan_mask] = mag_r_map.data[nan_mask]
+
+nrho = 100
+rss = 2.5
+pfss_in = pfsspy.Input(synoptic_map_br, nrho, rss)
+pfss_out = pfsspy.pfss(pfss_in)
+
+fig, axs = plt.subplots(10, 3, figsize=(10, 10))
+b_potential = pfss_out.bg
+for i in range(10):
+    v_min_max = np.abs(b_potential[:, :, i]).max()
+    v_min_max = 500 if v_min_max > 500 else v_min_max
+    axs[i, 0].imshow(b_potential[:, :, i, 0].T, vmin=-v_min_max, vmax=v_min_max, cmap='gray', origin='lower')
+    axs[i, 1].imshow(b_potential[:, :, i, 1].T, vmin=-v_min_max, vmax=v_min_max, cmap='gray', origin='lower')
+    im = axs[i, 2].imshow(b_potential[:, :, i, 2].T, vmin=-v_min_max, vmax=v_min_max, cmap='gray', origin='lower')
+    divider = make_axes_locatable(axs[i, 2])
+    cax = divider.append_axes("right", size="5%", pad=0.05)
+    plt.colorbar(im, cax=cax)
+
+[ax.axis('off') for ax in axs.ravel()]
+plt.tight_layout()
+plt.savefig(os.path.join(out_path, 'potential.jpg'), dpi=300)
+plt.close()
+
+vtk_path = os.path.join(out_path, 'potential.vtk')
+
+spherical_bounds = np.stack(
+    np.meshgrid(np.linspace(radius_range[0], radius_range[1], 50),
+                np.linspace(latitude_range[0], latitude_range[1], 50),
+                np.linspace(longitude_range[0], longitude_range[1], 50), indexing='ij'), -1)
+
+cartesian_bounds = spherical_to_cartesian(spherical_bounds)
+
+x_min, x_max = cartesian_bounds[..., 0].min(), cartesian_bounds[..., 0].max()
+y_min, y_max = cartesian_bounds[..., 1].min(), cartesian_bounds[..., 1].max()
+z_min, z_max = cartesian_bounds[..., 2].min(), cartesian_bounds[..., 2].max()
+
+x_min, x_max = -1.3, 1.3
+y_min, y_max = -1.3, 1.3
+z_min, z_max = -1.3, 1.3
+
+coords = np.stack(
+    np.meshgrid(np.linspace(x_min, x_max, int((x_max - x_min) * pixels_per_solRad)),
+                np.linspace(y_min, y_max, int((y_max - y_min) * pixels_per_solRad)),
+                np.linspace(z_max, z_min, int((z_max - z_min) * pixels_per_solRad)), indexing='ij'), -1)
+# flipped z axis
+radius = np.sqrt(np.sum(coords ** 2, -1))
+
+spherical_coords = cartesian_to_spherical(coords)
+condition = (spherical_coords[..., 0] >= radius_range[0]) & (spherical_coords[..., 0] < radius_range[1]) \
+            & (spherical_coords[..., 1] > latitude_range[0]) & (spherical_coords[..., 1] < latitude_range[1]) \
+    # & (spherical_coords[..., 2] > longitude_range[0]) & (spherical_coords[..., 2] < longitude_range[1])
+spherical_coords[..., 1] -= np.pi / 2
+sub_coords = spherical_coords[condition]
+
+cube_shape = coords.shape[:-1]
+sky_sub_coords = SkyCoord(lon=sub_coords[..., 2] * u.rad,
+                      lat=(sub_coords[..., 1]) * u.rad,
+                      radius=sub_coords[..., 0] * u.solRad, frame=mag_r_map.coordinate_frame)
+sub_b = pfss_out.get_bvec(sky_sub_coords, out_type='cartesian')
+# sub_b[..., 2] *= -1  # flip z axis
+
+b = np.zeros(cube_shape + (3,))
+b[condition] = sub_b
+b = np.nan_to_num(b, nan=0)
+
+coords = np.stack(np.mgrid[0:b.shape[0], 0:b.shape[1], 0:b.shape[2]], -1).astype(np.int64)
+coords = (coords/ (b.shape[0] - 1) - 0.5) * 2 * 1.3
+
+save_vtk(vtk_path, coords=coords, vectors={'B': b})

nf2/data/analytical_field.py

@@ -0,0 +1,137 @@
+import numpy as np
+from scipy.integrate import solve_bvp
+
+
+def _differential_equation(mu, u, n, a2):
+    """
+    The differential equation to solve for P
+
+    :param mu: cos(theta)
+    :param u: P function and derivative
+    :param n: variable according to Low & Lou (1989)
+    :param a2: eigenvalue
+
+    """
+    P, dP = u
+    dP_dmu = dP
+    d2P_dmu2 = -(n * (n + 1) * P + a2 * (1 + n) / n * P ** (1 + 2 / n)) / (1 - mu ** 2 + 1e-8)
+    return (dP_dmu, d2P_dmu2)
+
+
+def get_analytic_b_field(n=1, m=1, l=0.3, psi=np.pi / 4, resolution=64, bounds=[-1, 1, -1, 1, 0, 2], tau_surfaces=None):
+    """
+    Calculate the analytic NLFF field from Low & Lou (1989).
+
+    :param n: variable see Low & Lou (1989), only works for n=1
+    :param m: used for generating a proper initial condition.
+    :param a2: eigenvalue
+    :param l: depth below the photosphere
+    :param psi: angle of the magnetic field relative to the dipol axis
+    :param resolution: spatial resolution of the magnetic field in pixels
+    :param bounds: dimensions of the volume (x_start, x_end, y_start, y_end, z_start, z_end)
+    :return: magnetic field B (x, y, z, v)
+    """
+    sol_P, a2 = solve_P(n, m)
+
+    resolution = [resolution] * 3 if not isinstance(resolution, list) else resolution
+    if tau_surfaces:
+        coords = np.stack(np.meshgrid(np.linspace(bounds[0], bounds[1], resolution[0], dtype=np.float32),
+                                      np.linspace(bounds[2], bounds[3], resolution[1], dtype=np.float32),
+                                      np.ones(len(tau_surfaces), dtype=np.float32),
+                                      indexing='ij'), -1)
+        for i, c in enumerate(tau_surfaces):
+            coords[:, :, i, 2] = c / resolution[2] * (bounds[5] - bounds[4]) + bounds[4]
+            if c == 0: # no corrugation for photospheric layer
+                continue
+            sx = sy = c / resolution[2] + 0.5
+            x, y = coords[:, :, i, 0], coords[:, :, i, 1]
+            gaussian = np.exp(-(x**2. / (2. * sx**2.) + y **2. / (2. * sy**2.)))
+            gaussian /= gaussian.max() # normalize
+            coords[:, :, i, 2] *= gaussian
+    else:
+        coords = np.stack(np.meshgrid(np.linspace(bounds[0], bounds[1], resolution[0], dtype=np.float32),
+                                      np.linspace(bounds[2], bounds[3], resolution[1], dtype=np.float32),
+                                      np.linspace(bounds[4], bounds[5], resolution[2], dtype=np.float32),
+                                      indexing='ij'), -1)
+
+    x, y, z = coords[..., 0], coords[..., 1], coords[..., 2]
+    X = x * np.cos(psi) - (z + l) * np.sin(psi)
+    Y = y
+    Z = x * np.sin(psi) + (z + l) * np.cos(psi)
+
+    # to spherical coordinates
+    xy = X ** 2 + Y ** 2
+    r = np.sqrt(xy + Z ** 2)
+    theta = np.arctan2(np.sqrt(xy), Z)
+    phi = np.arctan2(Y, X)
+
+    mu = np.cos(theta)
+
+    P, dP_dmu = sol_P(mu)
+    A = P / r ** n
+    dA_dtheta = -np.sin(theta) / (r ** n) * dP_dmu
+    dA_dr = P * (-n * r ** (-n - 1))
+    Q = np.sqrt(a2) * A * np.abs(A) ** (1 / n)
+
+    Br = (r ** 2 * np.sin(theta)) ** -1 * dA_dtheta
+    Btheta = - (r * np.sin(theta)) ** -1 * dA_dr
+    Bphi = (r * np.sin(theta)) ** -1 * Q
+
+    BX = Br * np.sin(theta) * np.cos(phi) + Btheta * np.cos(theta) * np.cos(phi) - Bphi * np.sin(phi)
+    BY = Br * np.sin(theta) * np.sin(phi) + Btheta * np.cos(theta) * np.sin(phi) + Bphi * np.cos(phi)
+    BZ = Br * np.cos(theta) - Btheta * np.sin(theta)
+
+    Bx = BX * np.cos(psi) + BZ * np.sin(psi)
+    By = BY
+    Bz = - BX * np.sin(psi) + BZ * np.cos(psi)
+
+    b_field = np.real(np.stack([Bx, By, Bz], -1))
+    return b_field
+
+
+def solve_P(n, m):
+    """
+    Solve the differential equation from Low & Lou (1989).
+
+    :param n: variable (only n=1)
+    :param v0: start condition for dP/dmu
+    :param P0: boundary condition for P(-1) and P(1)
+    :return: interpolated functions for P and dP/dmu
+    """
+
+    def f(x, y, p):
+        a2 = p[0]
+        d2P_dmu2 = -(n * (n + 1) * y[0] + a2 * (1 + n) / n * y[0] ** (1 + 2 / n)) / (1 - x ** 2 + 1e-6)
+        return [y[1], d2P_dmu2]
+
+    def f_boundary(Pa, Pb, p):
+        return np.array([Pa[0] - 0, Pb[0] - 0, Pa[1] - 10])
+
+    mu = np.linspace(-1, 1, num=256)
+
+    if m % 2 == 0:
+        init = np.cos(mu * (m + 1) * np.pi / 2)
+    else:
+        init = np.sin(mu * (m + 1) * np.pi / 2)
+
+    dinit = 10 * np.ones_like(init)  #
+    initial = np.stack([init, dinit])
+
+    @np.vectorize
+    def shooting(a2_init):
+        eval = solve_bvp(f, f_boundary, x=mu, y=initial, p=[a2_init], verbose=0, tol=1e-6)
+        if eval.success == False:
+            return None
+        return eval
+
+    # use shooting to find eigenvalues
+    evals = shooting(np.linspace(0, 10, 100, dtype=np.float32))
+    evals = [e for e in evals if e is not None]
+
+    eigenvalues = np.array([e.p for e in evals])
+    eigenvalues = sorted(set(np.round(eigenvalues, 4).reshape((-1,))))
+
+    # get final solution
+    eval = shooting([eigenvalues[-1]])[0]
+
+    return eval.sol, eval.p[0]