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)
