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 plasma.composition = [d_species, he2_species, c6_species, ne10_species] # BEAM ------------------------------------------------------------------------ beam = Beam(parent=world, transform=translate(1.0, 0.0, 0) * rotate(90, 0, 0)) beam.plasma = plasma beam.atomic_data = adas beam.energy = 60000 beam.power = 3e6 beam.element = elements.deuterium beam.sigma = 0.025 beam.divergence_x = 0.5 beam.divergence_y = 0.5 beam.length = 3.0 beam.attenuator = SingleRayAttenuator(clamp_to_zero=True)
imp_temperature = IonFunction(peak_temperature,
0,
pedestal_top=pedestal_top)
imp_distribution = Maxwellian(imp_density, imp_temperature,
velocity_profile,
impurity.atomic_weight * atomic_mass)
species.append(Species(impurity, ionisation, imp_distribution))
# define the electron distribution
e_density = IonFunction(peak_density, 0, pedestal_top=pedestal_top)
e_temperature = IonFunction(peak_temperature, 0, pedestal_top=pedestal_top)
e_distribution = Maxwellian(e_density, e_temperature, velocity_profile,
electron_mass)
# define species
plasma.b_field = ConstantVector3D(Vector3D(0, 0, 0))
plasma.electron_distribution = e_distribution
plasma.composition = species
####################
# 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
h1_temp = h1.distribution.effective_temperature
r, _, z, t_samples = sample3d(h1_temp, (-1, 2, 200), (0, 0, 1), (-1, 1, 200))
plt.imshow(np.transpose(np.squeeze(t_samples)), extent=[-1, 2, -1, 1])
plt.colorbar()
def create_plasma(self, parent=None, transform=None, name=None):
"""
Make a CHERAB plasma object from this SOLEGE2D simulation.
:param Node parent: The plasma's parent node in the scenegraph, e.g. a World object.
:param AffineMatrix3D transform: Affine matrix describing the location and orientation
of the plasma in the world.
:param str name: User friendly name for this plasma (default = "SOLEDGE2D Plasma").
:rtype: Plasma
"""
mesh = self.mesh
name = name or "SOLEDGE2D Plasma"
plasma = Plasma(parent=parent, transform=transform, name=name)
radius = mesh.mesh_extent['maxr']
height = mesh.mesh_extent['maxz'] - mesh.mesh_extent['minz']
plasma.geometry = Cylinder(radius, height)
plasma.geometry_transform = translate(0, 0, mesh.mesh_extent['minz'])
tri_index_lookup = self.mesh.triangle_index_lookup
tri_to_grid = self.mesh.triangle_to_grid_map
if isinstance(self._b_field_vectors, np.ndarray):
plasma.b_field = SOLEDGE2DVectorFunction3D(
tri_index_lookup, tri_to_grid, self._b_field_vectors_cartesian)
else:
print(
'Warning! No magnetic field data available for this simulation.'
)
# Create electron species
triangle_data = _map_data_onto_triangles(self._electron_temperature)
electron_te_interp = Discrete2DMesh(mesh.vertex_coords,
mesh.triangles,
triangle_data,
limit=False)
electron_temp = AxisymmetricMapper(electron_te_interp)
triangle_data = _map_data_onto_triangles(self._electron_density)
electron_ne_interp = Discrete2DMesh.instance(electron_te_interp,
triangle_data)
electron_dens = AxisymmetricMapper(electron_ne_interp)
electron_velocity = lambda x, y, z: Vector3D(0, 0, 0)
plasma.electron_distribution = Maxwellian(electron_dens, electron_temp,
electron_velocity,
electron_mass)
if not isinstance(self.velocities_cartesian, np.ndarray):
print(
'Warning! No velocity field data available for this simulation.'
)
b2_neutral_i = 0 # counter for B2 neutrals
for k, sp in enumerate(self.species_list):
# Identify the species based on its symbol
symbol, charge = re.match(_SPECIES_REGEX, sp).groups()
charge = int(charge)
species_type = _species_symbol_map[symbol]
# If neutral and B" atomic density available, use B2 density, otherwise use fluid species density.
if isinstance(self.b2_neutral_densities,
np.ndarray) and charge == 0:
species_dens_data = self.b2_neutral_densities[:, :,
b2_neutral_i]
b2_neutral_i += 1
else:
species_dens_data = self.species_density[:, :, k]
triangle_data = _map_data_onto_triangles(species_dens_data)
dens = AxisymmetricMapper(
Discrete2DMesh.instance(electron_te_interp, triangle_data))
# dens = SOLPSFunction3D(tri_index_lookup, tri_to_grid, species_dens_data)
# Create the velocity vector lookup function
if isinstance(self.velocities_cartesian, np.ndarray):
velocity = SOLEDGE2DVectorFunction3D(
tri_index_lookup, tri_to_grid,
self.velocities_cartesian[:, :, k, :])
else:
velocity = lambda x, y, z: Vector3D(0, 0, 0)
distribution = Maxwellian(dens, electron_temp, velocity,
species_type.atomic_weight * atomic_mass)
plasma.composition.add(Species(species_type, charge, distribution))
return plasma
# ########################### 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')
plasma = Plasma(parent=world)
plasma.atomic_data = adas
plasma.b_field = VectorAxisymmetricMapper(equil_time_slice.b_field)
DATA_PATH = '/pulse/{}/ppf/signal/{}/{}/{}:{}'
user = '******'
sequence = 0
psi_coord = sal.get(
DATA_PATH.format(PULSE_PLASMA, user, 'PRFL', 'C6',
sequence)).dimensions[0].data
mask = psi_coord <= 1.0
psi_coord = psi_coord[mask]
flow_velocity_tor_data = sal.get(
DATA_PATH.format(PULSE_PLASMA, user, 'PRFL', 'VT', sequence)).data[mask]
flow_velocity_tor_psi = Interpolate1DCubic(psi_coord, flow_velocity_tor_data)
flow_velocity_tor = AxisymmetricMapper(
