from cherab.openadas import OpenADAS, print_available_adf15_rates
adas = OpenADAS()
print_available_adf15_rates("adf15/pec96#c/pec96#c_vsu#c1.dat")
print()
print()
print_available_adf15_rates("pec96#he_pju#he0.dat")
print()
print()
print_available_adf15_rates("pec96#he_pju#he1.dat")
print()
print()
print_available_adf15_rates("pec12#h_pju#h0.dat")
from cherab.openadas import OpenADAS
###############
# Make Plasma #
width = 1.0
length = 1.0
height = 3.0
peak_density = 5e19
pedestal_top = 1
neutral_temperature = 0.5
peak_temperature = 2500
impurities = [(carbon, 6, 0.005)]
world = World()
adas = OpenADAS(permit_extrapolation=True, missing_rates_return_null=True)
plasma = Plasma(parent=world)
plasma.atomic_data = adas
plasma.geometry = Box(Point3D(0, -width / 2, -height / 2),
Point3D(length, width / 2, height / 2))
species = []
# make a non-zero velocity profile for the plasma
vy_profile = IonFunction(1E5, 0, pedestal_top=pedestal_top)
def vectorfunction3d(x, y, z):
vy = vy_profile(x, y, z)
return Vector3D(0, vy, 0)
from cherab.core.math import ConstantVector3D
from cherab.core.atomic.elements import deuterium, nitrogen
from cherab.core.model import ExcitationLine, RecombinationLine,\
MultipletLineShape, StarkBroadenedLine
from cherab.openadas import OpenADAS
from cherab.tools.plasmas import GaussianVolume
# tunables
ion_density = 1e20
sigma = 0.25
# setup scenegraph
world = 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))
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
r, _, z, t_samples = sample3d(ti, (-1, 2, 200), (0, 0, 1), (-1, 1, 200))
for cad_file in MESH_PARTS:
directory, filename = os.path.split(cad_file)
name, ext = filename.split('.')
print("importing {} ...".format(filename))
Mesh.from_file(cad_file,
parent=world,
material=AbsorbingSurface(),
name=name) # material=Lambert(ConstantSF(0.25))
# Load plasma from SOLPS model
mds_server = 'solps-mdsplus.aug.ipp.mpg.de:8001'
ref_number = 69636 #69637
sim = load_solps_from_mdsplus(mds_server, ref_number)
plasma = sim.create_plasma(parent=world)
plasma.atomic_data = OpenADAS(permit_extrapolation=True)
mesh = sim.mesh
vessel = mesh.vessel
# Pick emission models
# d_alpha = Line(deuterium, 0, (3, 2))
# plasma.models = [ExcitationLine(d_alpha), RecombinationLine(d_alpha)]
# d_gamma = Line(deuterium, 0, (5, 2))
# plasma.models = [ExcitationLine(d_gamma), RecombinationLine(d_gamma)]
ciii_465 = Line(carbon, 2, ('2s1 3p1 3P4.0', '2s1 3s1 3S1.0'))
plasma.models = [ExcitationLine(ciii_465)]
# Select from available Cameras
# camera_config = load_calcam_calibration('/home/mcarr/mastu/cameras/mug_bulletb_midplane.nc')
VectorAxisymmetricMapper
from cherab.core import Plasma, Maxwellian, Species
from cherab.core.atomic import Line, deuterium, carbon
from cherab.core.model import SingleRayAttenuator, BeamCXLine
from cherab.openadas import OpenADAS
from cherab.jet.nbi import load_pini_from_ppf
from cherab.jet.equilibrium import JETEquilibrium
from cherab.jet.machine import import_jet_mesh
PULSE = 79666
PULSE_PLASMA = 79503 # /!\ Plasma configuration is from pulse 79503!
TIME = 61.0
world = World()
adas = OpenADAS(permit_extrapolation=True) # create atomic data source
import_jet_mesh(world)
# ########################### PLASMA EQUILIBRIUM ############################ #
print('Plasma equilibrium')
equilibrium = JETEquilibrium(PULSE)
equil_time_slice = equilibrium.time(TIME)
psin_2d = equil_time_slice.psi_normalised
psin_3d = AxisymmetricMapper(equil_time_slice.psi_normalised)
inside_lcfs = equil_time_slice.inside_lcfs
# ########################### PLASMA CONFIGURATION ########################## #
print('Plasma configuration')
"""
import numpy as np
from raysect.optical import World
from cherab.core.atomic import carbon, deuterium, Isotope
from cherab.solps import load_solps_from_mdsplus
from cherab.openadas import OpenADAS
def no_radiation(*_):
"""Placeholder for when rates are not found"""
return 0
world = World()
adas = OpenADAS(permit_extrapolation=True) # create atomic data source
SPECIES_MAP = {
'D0': (deuterium, 0),
'D+1': (deuterium, 1),
'C0': (carbon, 0),
'C+1': (carbon, 1),
'C+2': (carbon, 2),
'C+3': (carbon, 3),
'C+4': (carbon, 4),
'C+5': (carbon, 5),
'C+6': (carbon, 6)
}
mds_server = 'solps-mdsplus.aug.ipp.mpg.de:8001'
ref_number = 69636
import numpy as np
import matplotlib.pyplot as plt
from cherab.core.atomic import deuterium, helium, carbon
from cherab.openadas import OpenADAS
adas = OpenADAS()
# load the PEC rate objects for transitions of interest
dalpha = adas.impact_excitation_pec(deuterium, 0, (3, 2))
heliumii_468 = adas.impact_excitation_pec(helium, 1, (4, 3))
carbonii_515 = adas.impact_excitation_pec(
carbon, 1, ("2s1 2p1 3d1 2D4.5", "2s2 4d1 2D4.5"))
carboniii_465 = adas.impact_excitation_pec(carbon, 2,
("2s1 3p1 3P4.0", "2s1 3s1 3S1.0"))
# settings for plot range
temp_low = 1
temp_high = 1000
num_points = 100
electron_density = 1E19
electron_temperatures = [
10**x for x in np.linspace(
np.log10(temp_low), np.log10(temp_high), num=num_points)
]
# sample the PECs
dalpha_pecs = []
heliumii_468_pecs = []
carbonii_515_pecs = []
carboniii_465_pecs = []
parser.add_argument('-l', '--line', help='The emission line that will be simulated.',
choices=list(available_lines.keys()), default='d-alpha')
parser.add_argument('-o', '--output', help='The name of an output file to which the data and an'
'image will be written (excluding file extensions).')
args = parser.parse_args()
sensitivity = load_kl11_sensitivity_matrix(camera='c')
voxel_grid = load_kl11_voxel_grid()
camera = load_kl11_camera(stride=3)
edge2d_sim = load_edge2d_from_eproc(args.sim_path)
# edge2d_sim = load_edge2d_from_eproc('/common/cmg/jsimpson/edge2d/runs/run1708151A/tran')
plasma = edge2d_sim.create_plasma()
plasma.atomic_data = OpenADAS()
excitation_model = ExcitationLine(available_lines[args.line])
# excitation_model = ExcitationLine(available_lines['d-alpha'])
recombination_model = RecombinationLine(available_lines[args.line])
# recombination_model = RecombinationLine(available_lines['d-alpha'])
plasma.models = [excitation_model, recombination_model]
class EmissionFunction(PythonFunction3D):
def __init__(self, model):
self.model = model
def __call__(self, x, y, z):
world = World()
import_jet_mesh(world, override_material=AbsorbingSurface())
kb5v_collimator_mesh = import_obj(KB5V[0][0],
scaling=0.001,
parent=world,
material=AbsorbingSurface())
kb5h_collimator_mesh = import_obj(KB5H[0][0],
scaling=0.001,
parent=world,
material=AbsorbingSurface())
edge2d_sim = load_edge2d_from_eproc(args.sim_path)
# edge2d_sim = load_edge2d_from_eproc('/common/cmg/jsimpson/edge2d/runs/run1708151A/tran')
plasma = edge2d_sim.create_plasma(parent=world)
plasma.atomic_data = OpenADAS(missing_rates_return_null=True)
models = []
for species in plasma.composition:
models.append(TotalRadiatedPower(species.element, species.charge))
plasma.models = models
plt.ion()
plt.figure()
xrange = np.linspace(0, 4, 200)
yrange = np.linspace(-2, 2, 200)
rad_rz_intensity = np.zeros((200, 200))
direction = Vector3D(0, 1, 0)
for i, x in enumerate(xrange):
for j, y in enumerate(yrange):
for model in models:
def __init__(self, solps_ref_no, view, line, camera, optics='MAST_CI_mod', cherab_down_sample=50, verbose=True,
display=False, overwrite=False):
"""
:param solps_ref_no: int
:param view: str
:param line: str
:param camera: str
:param optics: str
:param cherab_down_sample: int downsample the image by ths factor in both dimensions, for speed / testing.
:param verbose: bool
:param display: bool
:param overwrite: bool
"""
self.world = World()
self.solps_ref_no = solps_ref_no
self.line = line
self.view = view
self.camera = camera
self.optics = optics
self.cherab_down_sample = cherab_down_sample
self.verbose = verbose
self.display = display
self.overwrite = overwrite
self.radiance = NotImplemented
self.spectral_radiance = NotImplemented
self.pupil_point = settings.view[self.view]['pupil_point']
self.view_vector = settings.view[self.view]['view_vector']
self.sensor_format = settings.camera[self.camera]['sensor_format']
for s in self.sensor_format:
assert s % cherab_down_sample == 0
self.sensor_format_ds = tuple((np.array(self.sensor_format) / cherab_down_sample).astype(np.int))
self.pixel_size = settings.camera[self.camera]['pixel_size']
self.pixel_size_ds = self.pixel_size * cherab_down_sample
self.x, self.y, = self.calc_pixel_position(self.pixel_size, self.sensor_format)
self.x_pixel = self.x.x_pixel
self.y_pixel = self.y.y_pixel
self.x_ds = self.x.isel(x=slice(0, self.sensor_format[0], cherab_down_sample, ))
self.y_ds = self.y.isel(y=slice(0, self.sensor_format[1], cherab_down_sample, ))
self.x_pixel_ds = self.x_ds.x_pixel
self.y_pixel_ds = self.y_ds.y_pixel
self.chunks = {'x': 800, 'y': 800}
# calculate field of view (FOV) (horizontal) using sensor geometry and lens focal lengths
f_1, f_2, f_3 = settings.optics[self.optics]
sensor_dim = self.sensor_format[0] * self.pixel_size
self.fov = 2 * np.arctan((sensor_dim / 2) * f_2 / (f_3 * f_1)) * 180 / np.pi # deg
#
# file and directory paths
self.dir_name = str(solps_ref_no) + '_' + view + '_' + line + '_' + camera
self.dir_path = os.path.join(path_saved_data, self.dir_name)
fname = 'spec_power.nc'
fname_ds = 'spec_power_ds.nc'
self.fpath_ds = os.path.join(self.dir_path, fname_ds, )
self.fpath = os.path.join(self.dir_path, fname, )
# load SOLPS plasma and set emission line model
self.sim = load_solps_from_mdsplus(mds_server, self.solps_ref_no)
self.plasma = self.sim.create_plasma(parent=self.world)
self.plasma.atomic_data = OpenADAS(permit_extrapolation=True)
emission_line = settings.line[self.line]
element, charge, transition = [emission_line[s] for s in ['element', 'charge', 'transition', ]]
line_obj = Line(element, charge, transition, )
self._line_excit = ExcitationLine(line_obj, lineshape=StarkBroadenedLine)
self._line_recom = RecombinationLine(line_obj, lineshape=StarkBroadenedLine)
self.plasma.models = [Bremsstrahlung(), self._line_excit, self._line_recom]
wl_0_nm = self._line_excit.atomic_data.wavelength(element, charge, transition, )
self.wl_0 = wl_0_nm * 1e-9 # [m]
self.wl_min_nm, self.wl_max_nm = wl_0_nm - 0.2, wl_0_nm + 0.2 # [m]
# ugly, but I want to convert the density units to 10^{20} m^{-3}
def get_ne(x, y, z, ):
return 1e-20 * self.plasma.electron_distribution.density(x, y, z, )
def get_ni(x, y, z, ):
return 1e-20 * self.plasma.composition.get(deuterium, 0).distribution.density(x, y, z, )
def get_b_field_mag(x, y, z, ):
"""
magnitude of the magnetic field at x, y, z
:param x:
:param y:
:param z:
:return:
"""
return self.plasma.b_field(x, y, z, ).length
def get_emiss_excit(x, y, z, ):
return self._line_excit.emission(Point3D(x, y, z, ), Vector3D(1, 1, 1), Spectrum(380, 700, 100)).total()
def get_emiss_recom(x, y, z, ):
return self._line_recom.emission(Point3D(x, y, z, ), Vector3D(1, 1, 1), Spectrum(380, 700, 100)).total()
self.valid_param_get_fns = {'ne': get_ne,
'ni': get_ni,
'te': self.plasma.electron_distribution.effective_temperature,
'ti': self.plasma.composition.get(deuterium, 0).distribution.effective_temperature,
'tn': self.plasma.composition.get(deuterium, 1).distribution.effective_temperature,
'b_field_mag': get_b_field_mag,
'emiss_excit': get_emiss_excit,
'emiss_recom': get_emiss_recom,
}
self.valid_params = list(self.valid_param_get_fns.keys())
# load / make the cherab image
if os.path.isdir(self.dir_path) and self.overwrite is False:
if os.path.isfile(self.fpath) and os.path.isfile(self.fpath_ds):
pass
else:
if not os.path.isdir(self.dir_path):
os.mkdir(self.dir_path)
self.make_cherab_image()
ds, ds_ds = self.load_cherab_image()
self.spectral_radiance = ds['spectral_radiance']
self.radiance = self.spectral_radiance.integrate(dim='wavelength')
self.radiance = xr.where(xr.ufuncs.isnan(self.radiance), 0, self.radiance, )
self.spectral_radiance_ds = ds_ds['spectral_radiance_ds']
self.radiance_ds = ds_ds['radiance_ds']
self.view_vectors = ds_ds['view_vectors_ds']
self.ray_lengths = ds_ds['ray_lengths_ds']
ds.close()
import numpy as np
import matplotlib.pyplot as plt
from cherab.core.atomic import neon, carbon, helium, hydrogen
from cherab.openadas import OpenADAS
adas = OpenADAS(permit_extrapolation=True)
electron_temperatures = [
10**x for x in np.linspace(np.log10(1), np.log10(10000), num=100)
]
electron_density = 1e19
elem = neon
numstates = elem.atomic_number + 1
# Collect rate coefficients
coef_tcx = {}
for i in np.arange(1, elem.atomic_number + 1):
coef_tcx[i] = adas.thermal_cx_rate(hydrogen, 0, neon, int(i))
# test correctness of available charge numbers
try:
adas.thermal_cx_rate(hydrogen, 0, neon, i)
except RuntimeError:
print(
"Check that thermal charge exchange between a neutral element and neutral hydrogen "
"is not allowed.")
fig_tcxrates = plt.subplots()
ax = fig_tcxrates[1]
