def test_integration_2d(self): """ Testing against ToroidalVoxelGrid""" world = World() rtc = RayTransferCylinder(radius_outer=4., height=2., n_radius=2, n_height=2, radius_inner=2., parent=world) rtc.step = 0.001 * rtc.step ray = Ray(origin=Point3D(4., 1., 2.), direction=Vector3D(-4., -1., -2.) / np.sqrt(21.), min_wavelength=500., max_wavelength=501., bins=rtc.bins) spectrum = ray.trace(world) world = World() vertices = [] for rv in [2., 3.]: for zv in [0., 1.]: vertices.append([ Point2D(rv, zv + 1.), Point2D(rv + 1., zv + 1.), Point2D(rv + 1., zv), Point2D(rv, zv) ]) tvg = ToroidalVoxelGrid(vertices, parent=world, primitive_type='csg', active='all') tvg.set_active('all') spectrum_test = ray.trace(world) self.assertTrue( np.allclose(spectrum_test.samples, spectrum.samples, atol=0.001))
def test_integration(self): world = World() rtb = RayTransferBox(xmax=3., ymax=3., zmax=3., nx=3, ny=3, nz=3, parent=world) rtb.step = 0.01 * rtb.step ray = Ray(origin=Point3D(4., 4., 4.), direction=Vector3D(-1., -1., -1.) / np.sqrt(3), min_wavelength=500., max_wavelength=501., bins=rtb.bins) spectrum = ray.trace(world) spectrum_test = np.zeros(rtb.bins) spectrum_test[0] = spectrum_test[13] = spectrum_test[26] = np.sqrt(3.) self.assertTrue( np.allclose(spectrum_test, spectrum.samples, atol=0.001))
def test_integration_3d(self): world = World() rtc = RayTransferCylinder(radius_outer=2., height=2., n_radius=2, n_height=2, n_polar=3, period=90., parent=world) rtc.step = 0.001 * rtc.step ray = Ray(origin=Point3D(np.sqrt(2.), np.sqrt(2.), 2.), direction=Vector3D(-1., -1., -np.sqrt(2.)) / 2., min_wavelength=500., max_wavelength=501., bins=rtc.bins) spectrum = ray.trace(world) spectrum_test = np.zeros(rtc.bins) spectrum_test[2] = spectrum_test[9] = np.sqrt(2.) self.assertTrue( np.allclose(spectrum_test, spectrum.samples, atol=0.001))
def test_evaluate_function(self): """ Unlike test_integration() in TestRayTransferBox here we test how CartesianRayTransferEmitter works with NumericalIntegrator. """ world = World() material = CartesianRayTransferEmitter( (3, 3, 3), (1., 1., 1.), integrator=NumericalIntegrator(0.0001)) box = Box(lower=Point3D(0, 0, 0), upper=Point3D(2.99999, 2.99999, 2.99999), material=material, parent=world) ray = Ray(origin=Point3D(4., 4., 4.), direction=Vector3D(-1., -1., -1.) / np.sqrt(3), min_wavelength=500., max_wavelength=501., bins=material.bins) spectrum = ray.trace(world) spectrum_test = np.zeros(material.bins) spectrum_test[0] = spectrum_test[13] = spectrum_test[26] = np.sqrt(3.) self.assertTrue( np.allclose(spectrum_test, spectrum.samples, atol=0.001))
def test_evaluate_function_2d(self): """ Unlike test_integration_2d() in TestRayTransferCylinder here we test how CylindricalRayTransferEmitter works with NumericalIntegrator in axysimmetric case. Testing against ToroidalVoxelGrid. """ world = World() material = CylindricalRayTransferEmitter( (2, 2), (1., 1.), rmin=2., integrator=NumericalIntegrator(0.0001)) primitive = Subtract(Cylinder(3.999999, 1.999999), Cylinder(2.0, 1.999999), material=material, parent=world) ray = Ray(origin=Point3D(4., 1., 2.), direction=Vector3D(-4., -1., -2.) / np.sqrt(21.), min_wavelength=500., max_wavelength=501., bins=4) spectrum = ray.trace(world) world = World() vertices = [] for rv in [2., 3.]: for zv in [0., 1.]: vertices.append([ Point2D(rv, zv + 1.), Point2D(rv + 1., zv + 1.), Point2D(rv + 1., zv), Point2D(rv, zv) ]) tvg = ToroidalVoxelGrid(vertices, parent=world, primitive_type='csg', active='all') tvg.set_active('all') spectrum_test = ray.trace(world) self.assertTrue( np.allclose(spectrum_test.samples, spectrum.samples, atol=0.001))
def test_evaluate_function_3d(self): """ Unlike test_integration_3d() in TestRayTransferCylinder here we test how CylindricalRayTransferEmitter works with NumericalIntegrator in 3D case. """ world = World() material = CylindricalRayTransferEmitter( (2, 3, 2), (1., 30., 1.), period=90., integrator=NumericalIntegrator(0.0001)) primitive = Subtract(Cylinder(1.999999, 1.999999), Cylinder(0.000001, 1.999999), material=material, parent=world) ray = Ray(origin=Point3D(np.sqrt(2.), np.sqrt(2.), 2.), direction=Vector3D(-1., -1., -np.sqrt(2.)) / 2., min_wavelength=500., max_wavelength=501., bins=12) spectrum = ray.trace(world) spectrum_test = np.zeros(12) spectrum_test[2] = spectrum_test[9] = np.sqrt(2.) self.assertTrue( np.allclose(spectrum_test, spectrum.samples, atol=0.001))
adas = OpenADAS(permit_extrapolation=True) # PLASMA ---------------------------------------------------------------------- plasma = Plasma(parent=world) # define basic distributions ion_density = 9e19 sigma = 0.25 d_density = GaussianVolume(0.94 * ion_density, sigma) he2_density = GaussianVolume(0.04 * ion_density, sigma) c6_density = GaussianVolume(0.01 * ion_density, sigma) ne10_density = GaussianVolume(0.01 * ion_density, sigma) e_density = GaussianVolume((0.94 + 0.04*2 + 0.01*6 + 0.01*10) * ion_density, sigma) temperature = 1000 + GaussianVolume(4000, sigma) bulk_velocity = ConstantVector3D(Vector3D(200e3, 0, 0)) d_distribution = Maxwellian(d_density, temperature, bulk_velocity, elements.deuterium.atomic_weight * atomic_mass) he2_distribution = Maxwellian(he2_density, temperature, bulk_velocity, elements.helium.atomic_weight * atomic_mass) c6_distribution = Maxwellian(c6_density, temperature, bulk_velocity, elements.carbon.atomic_weight * atomic_mass) ne10_distribution = Maxwellian(ne10_density, temperature, bulk_velocity, elements.neon.atomic_weight * atomic_mass) e_distribution = Maxwellian(e_density, temperature, bulk_velocity, electron_mass) d_species = Species(elements.deuterium, 1, d_distribution) he2_species = Species(elements.helium, 2, he2_distribution) c6_species = Species(elements.carbon, 6, c6_distribution) ne10_species = Species(elements.neon, 10, ne10_distribution) # define species plasma.b_field = ConstantVector3D(Vector3D(1.0, 1.0, 1.0)) plasma.electron_distribution = e_distribution
upper=Point3D(0.05, 0.05, 0), material=AbsorbingSurface(), transform=translate(0, 0, 0.1), parent=world) target.meta['viz-color'] = (224 / 255, 100 / 255, 17 / 255) # for each sample direction trace a logging ray and plot the ray trajectory plt.ion() fig = plt.figure() # ax = fig.gca(projection='3d') # for u in np.linspace(-0.006, 0.006, 5): for v in np.linspace(-0.012, 0.012, 11): start = Point3D(v, 0, -0.05) log_ray = LoggingRay(start, Vector3D(0, 0, 1)) log_ray.trace(world) vertices = log_ray.path_vertices p = [(v.x, v.z) for v in vertices] p = np.array(p) plt.plot(p[:, 0], p[:, 1], 'k-') plt.plot(p[:, 0], p[:, 1], 'r.') from raysect_mayavi import visualise_scenegraph from mayavi import mlab visualise_scenegraph(world)
# create atomic data source adas = OpenADAS(permit_extrapolation=True) # PLASMA ---------------------------------------------------------------------- plasma = Plasma(parent=world) plasma.atomic_data = adas plasma.geometry = Sphere(sigma * 5.0) plasma.geometry_transform = None plasma.integrator = NumericalIntegrator(step=sigma / 5.0) # define basic distributions d_density = GaussianVolume(0.5 * ion_density, sigma * 10000) n_density = d_density * 0.01 e_density = GaussianVolume(ion_density, sigma * 10000) temperature = 1 + GaussianVolume(79, sigma) bulk_velocity = ConstantVector3D(Vector3D(-1e6, 0, 0)) deuterium_mass = deuterium.atomic_weight * atomic_mass d_distribution = Maxwellian(d_density, temperature, bulk_velocity, deuterium_mass) nitrogen_mass = nitrogen.atomic_weight * atomic_mass n_distribution = Maxwellian(n_density, temperature, bulk_velocity, nitrogen_mass) e_distribution = Maxwellian(e_density, temperature, bulk_velocity, electron_mass) d0_species = Species(deuterium, 0, d_distribution) d1_species = Species(deuterium, 1, d_distribution) n1_species = Species(nitrogen, 1, n_distribution) # define species
from cherab.core.model.beam.beam_emission import SIGMA_TO_PI, SIGMA1_TO_SIGMA0, \ PI2_TO_PI3, PI4_TO_PI3 from cherab.tools.plasmas.slab import build_slab_plasma from cherab.openadas import OpenADAS ############### # Make Plasma # world = World() plasma = build_slab_plasma(width=1.0, height=3.0, peak_density=1e18, impurities=[(carbon, 6, 0.005)], parent=world) plasma.b_field = ConstantVector3D(Vector3D(0, 1.5, 0)) plasma.atomic_data = OpenADAS(permit_extrapolation=True) # add background emission d_alpha = Line(hydrogen, 0, (3, 2)) plasma.models = [ExcitationLine(d_alpha), RecombinationLine(d_alpha)] #################### # Visualise Plasma # h0 = plasma.composition.get(hydrogen, 0) h1 = plasma.composition.get(hydrogen, 1) c6 = plasma.composition.get(carbon, 6) # Run some plots to check the distribution functions and emission profile are as expected ti = h1.distribution.effective_temperature
image_start_y = 0.5 * num_pixels * image_delta x_points = [] y_points = [] z_points = [] z_show = np.zeros((num_pixels, num_pixels)) for ix in range(num_pixels): for iy in range(num_pixels): # generate pixel transform pixel_x = image_start_x - image_delta * ix pixel_y = image_start_y - image_delta * iy # calculate point in virtual image plane to be used for ray direction origin = Point3D().transform(translate(0, 0.16, -0.7) * rotate(0, -12, 0)) direction = Vector3D(pixel_x, pixel_y, 1).normalise().transform(translate(0, 0.16, -0.7) * rotate(0, -12, 0)) intersection = world.hit(CoreRay(origin, direction)) if intersection is not None: hit_point = intersection.hit_point.transform(intersection.primitive_to_world) x_points.append(hit_point.z) y_points.append(hit_point.x) z_points.append(hit_point.y) z_show[iy, ix] = hit_point.z else: # add small offset so background is black z_show[iy, ix] = 0.1 fig = plt.figure() ax = fig.add_subplot(111, projection='3d')
# create atomic data source adas = OpenADAS(permit_extrapolation=True) # PLASMA ---------------------------------------------------------------------- plasma = Plasma(parent=world) plasma.atomic_data = adas plasma.geometry = Sphere(sigma * 5.0) plasma.geometry_transform = None plasma.integrator = NumericalIntegrator(step=sigma / 5.0) # define basic distributions d_density = GaussianVolume(0.5 * ion_density, sigma*10000) e_density = GaussianVolume(ion_density, sigma*10000) temperature = 1 + GaussianVolume(79, sigma) bulk_velocity = ConstantVector3D(Vector3D(-1e6, 0, 0)) d_distribution = Maxwellian(d_density, temperature, bulk_velocity, elements.deuterium.atomic_weight * atomic_mass) e_distribution = Maxwellian(e_density, temperature, bulk_velocity, electron_mass) d0_species = Species(elements.deuterium, 0, d_distribution) d1_species = Species(elements.deuterium, 1, d_distribution) # define species plasma.b_field = ConstantVector3D(Vector3D(1.0, 1.0, 1.0)) plasma.electron_distribution = e_distribution plasma.composition = [d0_species, d1_species] # Setup elements.deuterium lines d_alpha = Line(elements.deuterium, 0, (3, 2)) d_beta = Line(elements.deuterium, 0, (4, 2))
# setup scenegraph world = World() ################### # plasma creation # plasma = Plasma(parent=world) plasma.atomic_data = OpenADAS(permit_extrapolation=True) plasma.geometry = Cylinder(3.5, 2.2, transform=translate(0, 0, -1.1)) plasma.geometry_transform = translate(0, 0, -1.1) # No net velocity for any species zero_velocity = ConstantVector3D(Vector3D(0, 0, 0)) # define neutral species distribution d0_density = NeutralFunction(peak_density, 0.1, magnetic_axis) d0_temperature = Constant3D(0.5) # constant 0.5eV temperature for all neutrals d0_distribution = Maxwellian(d0_density, d0_temperature, zero_velocity, deuterium.atomic_weight * atomic_mass) d0_species = Species(deuterium, 0, d0_distribution) # define deuterium ion species distribution d1_density = IonFunction(peak_density, 0, magnetic_axis) d1_temperature = IonFunction(peak_temperature, 0, magnetic_axis) d1_distribution = Maxwellian(d1_density, d1_temperature, zero_velocity, deuterium.atomic_weight * atomic_mass) d1_species = Species(deuterium, 1, d1_distribution)
from raysect.optical import World, translate, rotate, rotate_basis, Vector3D from raysect.optical.observer import PinholeCamera from raysect.primitive import Box world = World() box = Box(parent=world, transform=translate(1, 0, 0)*rotate_basis(Vector3D(1, 1, 0), Vector3D(0, 0, 1))) camera = PinholeCamera((256, 256), fov=40, parent=world, transform=translate(0, 0.16, -0.4) * rotate(0, -12, 0)) from raysect_vtk import visualise_scenegraph visualise_scenegraph(camera, focal_distance=3, zoom=0.5)
import numpy as np import matplotlib.pyplot as plt from raysect.core.math.function.function3d import PythonFunction3D from raysect.optical import World, Spectrum, Point3D, Vector3D from cherab.core.atomic import Line from cherab.core.atomic.elements import deuterium from cherab.core.model import ExcitationLine, RecombinationLine from cherab.edge2d import load_edge2d_from_eproc from cherab.openadas import OpenADAS from cherab.tools.inversions import invert_sart from cherab.jet.cameras.kl11 import load_kl11_voxel_grid, load_kl11_sensitivity_matrix X_VECTOR = Vector3D(1, 0, 0) class SimpleEmissionFunction: def __init__(self, excit, recom, spectral_settings): self.excit = excit self.recom = recom self.spectral_settings = spectral_settings def __call__(self, x, y, z): point = Point3D(x, y, z) spectrum = Spectrum(self.spectral_settings[0], self.spectral_settings[1], self.spectral_settings[2]) spectrum = self.excit.emission(point, X_VECTOR, spectrum)