def flux_coordinates_and_axes(draw, domain=((0.0, 1.0), (0.0, 1.0), (0.0, 1.0)), min_side=2, max_side=12): """Generates :py:class:`indica.converters.FluxSurfaceCoordinates` objects, along with axes. Parameters ---------- min_side : integer The minimum number of elements in an unaligned dimension for the default coordinate arrays. (Not available for all coordinate systems.) max_side : integer The maximum number of elements in an unaligned dimension for the default coordinate arrays. (Not available for all coordinate systems.) """ transform = draw(flux_coordinates(domain)) x1_vals, x2_vals, t_vals = map( np.ravel, draw( basis_coordinates((0.0, 0.0, 0.0), (1.0, 2 * np.pi, 120.0), min_side, max_side)), ) return ( transform, coord_array(x1_vals, transform.x1_name), coord_array(x2_vals, transform.x2_name), coord_array(t_vals, "t"), )
def test_spline_transect_coords_x1(): spline = Spline(func(R_grid, 0, t_grid), "R", trivial, "natural") indices = [1, 3, 5] alpha = coord_array(indices, coords.x1_name) alpha_z_offset = coord_array([0.2, 0.1], coords.x2_name) result = spline(coords, alpha, alpha_z_offset, t_grid) assert_allclose(result, func(R_positions[indices], 0.0, t_grid))
def test_broadcast_spline_2d(): x_interp = utilities.coord_array(np.linspace(0.2, 0.5, 3), "alpha") * utilities.coord_array( np.linspace(0.5, 1.0, 4), "beta") result = utilities.broadcast_spline(spline, spline_dims, spline_coords, x_interp) assert_allclose(result, func_3d(x_interp, y, t)) assert result.dims == ("alpha", "beta", "y", "t")
def trivial_transforms_and_axes(draw, domain=((0.0, 1.0), (0.0, 1.0), (0.0, 1.0)), min_side=2, max_side=12): transform = draw(trivial_transforms(domain)) min_vals, max_vals = zip(*domain) x1, x2, t = map( np.ravel, draw(basis_coordinates(min_vals, max_vals, min_side, max_side))) return ( transform, coord_array(x1, transform.x1_name), coord_array(x2, transform.x2_name), coord_array(t, "t"), )
def test_spline_fit(): flux_coords = FluxSurfaceCoordinates("poloidal") flux_coords.set_equilibrium(fake_equilib) knot_locations = [0.0, 0.5, 0.8, 1.05] knot_vals = (DataArray([1.0, 0.9, 0.6, 0.0], coords=[("rho_poloidal", knot_locations)]) + 0.05 * t_grid) knot_vals.loc[knot_locations[-1]] = 0.0 expected_spline = Spline(knot_vals, "rho_poloidal", flux_coords) input_vals = expected_spline(coords, R_positions.coords["alpha"], 0.0, t_grid).assign_coords(alpha_z_offset=0) input_vals.attrs["datatype"] = ("temperature", "electrons") fitter = SplineFit(knot_locations, sess=MagicMock()) result_locations = coord_array(np.linspace(0, 1.05, 10), "rho_poloidal") result, spline_fit, binned_input = fitter(result_locations, t_grid, input_vals) assert_allclose(input_vals, binned_input) assert_allclose(spline_fit, knot_vals.transpose(*spline_fit.dims)) assert_allclose( result, expected_spline(flux_coords, result_locations, 0.0, t_grid)) assert result.attrs["datatype"] == input_vals.attrs["datatype"] assert isinstance(result.attrs["splines"], Spline) assert result.attrs["transform"] == flux_coords assert "provenance" in result.attrs assert "provenance" in spline_fit.attrs assert "provenance" in binned_input.attrs
def magnetic_coordinates(draw, domain=((0.0, 1.0), (0.0, 1.0), (0.0, 1.0)), name=None): z, name, machine_dims = draw(magnetic_coordinate_arguments(domain, name)) if domain: Rmin = domain[0][0] else: Rmin = machine_dims[0][0] if Rmin < 0: Bcoeff = draw(floats(min(0.1, -0.01 / Rmin), min(10.0, -0.99 / Rmin))) else: Bcoeff = draw(floats(0.1, 10.0)) B_alpha = draw(floats(0.0, 1.0)) equilib = draw( fake_equilibria( draw(floats(*domain[0])), draw(floats(*domain[1])), coord_array( draw(monotonic_series(*domain[2], draw(integers(2, 20))), ), "t", ), Btot_alpha=B_alpha, Btot_b=Bcoeff, )) result = MagneticCoordinates(z, name, machine_dims) result.set_equilibrium(equilib) return result
def los_coordinates_and_axes( draw, domain=None, min_los=2, max_los=10, domain_as_dims=False, toroidal_skew=None, name=None, ): """Generates :py:class:`indica.converters.LinesOfSightTransform` objects with lines of sight radiating from a point. At present this point is on the edge of the Tokamak, for reasons of convenience. Parameters ---------- domain: Tuple[Tuple[float, float], Tuple[float, float]], optional A tuple giving the range of R-z values for which the transform is guaranteed to work: ``((Rmin, Rmax), (zmin, zmax)``. If absent will draw values. min_los: int The minimum number of lines of sight max_los: int The maximum number of lines of sight domain_as_dims: bool If True, use the domain as the machine dimensions. toroidal_skew: Optional[bool] Whether to include any toroidal angle to the lines of sight. Defaults to drawing a value to decide. name: Optional[str] The name of the camera these lines of sight are for. Returns ------- transform: TransectCoordinates The coordinate transform object. machine_dims: Tuple[Tuple[float, float], Tuple[float, float]] A tuple giving the boundaries of the Tokamak in R-z space: ``((Rmin, Rmax), (zmin, zmax)``. """ transform = draw( los_coordinates( domain, min_los, max_los, domain_as_dims, toroidal_skew, name, )) x1 = coord_array(np.arange(len(transform.x_start)), transform.x1_name) x2 = DataArray(0) t = DataArray(0) return transform, x1, x2, t
def test_coord_array(vals, name): coords = utilities.coord_array(vals, name) np.testing.assert_array_equal(coords.data, vals) np.testing.assert_array_equal(coords.coords[name], vals) assert len(coords.dims) == 1 datatype = coords.attrs["datatype"] if name == "R": assert datatype[0] == "major_rad" elif name == "t": assert datatype[0] == "time" elif name == "rho_poloidal": assert datatype[0] == "norm_flux_pol" elif name == "rho_toroidal": assert datatype[0] == "norm_flux_tor" else: assert datatype[0] == name assert datatype[1] == "plasma"
def magnetic_coordinates_and_axes( draw, domain=((0.0, 1.0), (0.0, 1.0), (0.0, 1.0)), name=None, min_vals=2, max_vals=5, ): transform = draw(magnetic_coordinates(domain, name)) width = transform.right - transform.left R_start = transform.right - draw(floats(0.001, 0.5 * width)) R_end = transform.left + draw(floats(0.001, 0.5 * width)) if R_start - R_end < 0.1 * width: R_start = +0.1 * width n = draw(integers(min_vals, max_vals)) R = DataArray(np.linspace(R_start, R_end, n)) x1 = coord_array( transform.convert_from_Rz(R, transform.z_los, 0)[0].data, transform.x1_name) x2 = DataArray(0) t = DataArray(0) return transform, x1, x2, t
def test_broadcast_spline_new_coord(): x_interp = utilities.coord_array(np.linspace(0.1, 0.4, 4), "x_new") result = utilities.broadcast_spline(spline, spline_dims, spline_coords, x_interp) assert_allclose(result, func_3d(x_interp, y, t)) assert result.dims == ("x_new", "y", "t")
elif name == "t": assert datatype[0] == "time" elif name == "rho_poloidal": assert datatype[0] == "norm_flux_pol" elif name == "rho_toroidal": assert datatype[0] == "norm_flux_tor" else: assert datatype[0] == name assert datatype[1] == "plasma" def func_3d(x, y, t): return 2 * x + 3 * y - 0.5 * t x = utilities.coord_array(np.linspace(0.0, 1.0, 5), "x") y = utilities.coord_array(np.linspace(0.0, 10.0, 4), "y") t = utilities.coord_array(np.linspace(50.0, 55.0, 6), "t") spline_dims = ("y", "t") spline_coords = {"y": y, "t": t} interp_data = func_3d(x, y, t) spline = scipy.interpolate.CubicSpline(x, interp_data, 0, "natural") def test_broadcast_spline_new_coord(): x_interp = utilities.coord_array(np.linspace(0.1, 0.4, 4), "x_new") result = utilities.broadcast_spline(spline, spline_dims, spline_coords, x_interp) assert_allclose(result, func_3d(x_interp, y, t)) assert result.dims == ("x_new", "y", "t")
import getpass import itertools import matplotlib.pyplot as plt import numpy as np from indica.equilibrium import Equilibrium from indica.operators import InvertRadiation from indica.readers import PPFReader from indica.utilities import coord_array cameras = ["v"] R = coord_array(np.linspace(1.83, 3.9, 25), "R") z = coord_array(np.linspace(-1.75, 2.0, 25), "z") t = coord_array(np.linspace(45, 50, 5), "t") reader = PPFReader(90279, 45.0, 50.0) if reader.requires_authentication: user = input("JET username: "******"JET password: "******"jetppf", "efit", 0) hrts = reader.get("jetppf", "hrts", 0) sxr = reader.get("jetppf", "sxr", 0) equilibrium = Equilibrium(equilib_dat) # , hrts["te"]) # ********************************************************************* for data in itertools.chain(hrts.values(), equilib_dat.values(), sxr.values()):
from indica.converters.time import strip_provenance from indica.utilities import coord_array from .test_abstract_transform import coordinate_transforms_and_axes from ..data_strategies import data_arrays_from_coords from ..strategies import polynomial_functions from ..strategies import sane_floats from ..strategies import separable_functions from ..strategies import smooth_functions start_times = floats(50.0, 120.0) end_times = start_times.map(lambda t: 120.0 - (t - 50.0)) samples = integers(2, 100) methods = sampled_from( ["nearest", "zero", "linear", "slinear", "quadratic", "cubic"]) t_axes = builds(np.linspace, just(50.0), just(120.0), integers(4, 50)).map(lambda t: coord_array(t, "t")) @composite def useful_data_arrays( draw, rel_sigma=0.02, abs_sigma=1e-3, data_strategy=separable_functions( smooth_functions(max_val=1e3), smooth_functions(max_val=1e3), smooth_functions(max_val=1e3), ), ): times = draw(t_axes) transform, x1, x2, _ = draw(coordinate_transforms_and_axes(min_side=2))
import getpass import itertools import matplotlib.pyplot as plt import numpy as np from indica.equilibrium import Equilibrium from indica.operators import SplineFit from indica.readers import PPFReader from indica.utilities import coord_array rho = coord_array(np.linspace(0, 1.04, 100), "rho_poloidal") t = coord_array(np.linspace(45, 50, 11), "t") reader = PPFReader(90279, 45.0, 50.0) if reader.requires_authentication: user = input("JET username: "******"JET password: "******"jetppf", "efit", 0) hrts = reader.get("jetppf", "hrts", 0) lidr = reader.get("jetppf", "lidr", 0) equilibrium = Equilibrium(equilib_dat) # ********************************************************************* for data in itertools.chain(hrts.values(), lidr.values()): data.indica.equilibrium = equilibrium
# Test the spline class fake_equilib = FakeEquilibrium(0.6, 0.0) R_positions = DataArray(np.linspace(1.0, 0.1, 10), coords=[ ("alpha", np.arange(10)) ]).assign_attrs(datatype=("major_rad", "plasma")) z_positions = DataArray(np.linspace(-0.1, 0.2, 10), coords=[("alpha", np.arange(10)) ]).assign_attrs(datatype=("z", "plasma")) coords = TransectCoordinates(R_positions, z_positions) coords.set_equilibrium(fake_equilib) trivial = TrivialTransform() R_grid = coord_array(np.linspace(0.0, 1.2, 7), "R") z_grid = coord_array(np.linspace(-1.0, 1.0, 5), "z") t_grid = coord_array(np.linspace(0.0, 10.0, 11), "t") def func(R, z, t): return R - z + 0.5 * t def test_spline_trivial_coords_R(): spline = Spline(func(R_grid, z_grid, t_grid), "R", trivial, "natural") R = coord_array(np.linspace(0.2, 0.8, 4), "R") result = spline(trivial, R, z_grid, t_grid) assert_allclose(result, func(R, z_grid, t_grid))
def test_spline_trivial_coords_z(): spline = Spline(func(R_grid, z_grid, t_grid), "z", trivial, "natural") z = coord_array(np.linspace(-0.2, 0.2, 5), "z") result = spline(trivial, R_grid, z, t_grid) assert_allclose(result, func(R_grid, z, t_grid).transpose(*result.dims))
def test_spline_trivial_coords_R(): spline = Spline(func(R_grid, z_grid, t_grid), "R", trivial, "natural") R = coord_array(np.linspace(0.2, 0.8, 4), "R") result = spline(trivial, R, z_grid, t_grid) assert_allclose(result, func(R, z_grid, t_grid))