radia 1.0.8__py3-none-any.whl → 1.0.9__py3-none-any.whl

python/radia_ngsolve_field.py

@@ -0,0 +1,374 @@
+"""
+Radia-NGSolve Field Integration
+
+Provides arbitrary background field from NGSolve CoefficientFunction or analytical functions.
+
+Date: 2025-10-31
+"""
+
+import radia as rad
+import numpy as np
+
+
+def create_cf_field_source(cf, unit='m'):
+	"""
+	Create Radia background field source from NGSolve CoefficientFunction.
+
+	Parameters
+	----------
+	cf : ngsolve.CoefficientFunction or callable
+	    NGSolve CF defining the field [Bx, By, Bz]
+	    CF should be evaluable at (x, y, z) and return 3-vector
+	    Can also be a Python function (x, y, z) -> [Bx, By, Bz]
+	unit : str, optional
+	    Unit of CF coordinates: 'm' (meters) or 'mm' (millimeters)
+	    Default: 'm' (NGSolve standard)
+
+	Returns
+	-------
+	int
+	    Radia object key for the field source
+
+	Examples
+	--------
+	>>> from ngsolve import CF, x, y, z
+	>>> # Create spatially varying field
+	>>> Bx = CF(0)
+	>>> By = CF(0)
+	>>> Bz = 1.0 + 0.01 * x  # Linear gradient in x
+	>>> B_cf = CF((Bx, By, Bz))
+	>>>
+	>>> # Register as Radia background field
+	>>> field_obj = create_cf_field_source(B_cf, unit='m')
+	>>> magnet = rad.ObjRecMag([0,0,0], [5,5,5], [0,0,1])
+	>>> container = rad.ObjCnt([magnet, field_obj])
+	>>> rad.Solve(container, 0.0001, 10000)
+
+	>>> # Check total field
+	>>> B_total = rad.Fld(container, 'b', [0, 0, 0])
+
+	Notes
+	-----
+	- Radia uses millimeters internally
+	- NGSolve typically uses meters
+	- This function handles unit conversion automatically
+	- For best performance with NGSolve CF, evaluate on a mesh with specialcf
+	"""
+
+	# Check if cf is NGSolve CF or Python callable
+	has_ngsolve = False
+	try:
+	    import ngsolve
+	    has_ngsolve = True
+	    is_ngsolve_cf = isinstance(cf, ngsolve.CoefficientFunction)
+	except ImportError:
+	    is_ngsolve_cf = False
+
+	if is_ngsolve_cf:
+	    # NGSolve CoefficientFunction: need special handling
+	    print("Warning: Direct NGSolve CF evaluation without mesh may be limited.")
+	    print("For best results, use create_analytical_field() with a function that")
+	    print("evaluates the CF on a GridFunction.")
+
+	    # Create wrapper for NGSolve CF
+	    def cf_wrapper(coords):
+	        """
+	        Wrapper to evaluate NGSolve CF at given point.
+
+	        Args:
+	            coords: [x, y, z] in mm (Radia units)
+
+	        Returns:
+	            [Bx, By, Bz] in Tesla
+	        """
+	        # Convert Radia mm to NGSolve units
+	        if unit == 'm':
+	            x_ngs = coords[0] / 1000.0  # mm → m
+	            y_ngs = coords[1] / 1000.0
+	            z_ngs = coords[2] / 1000.0
+	        else:  # unit == 'mm'
+	            x_ngs = coords[0]
+	            y_ngs = coords[1]
+	            z_ngs = coords[2]
+
+	        try:
+	            # Try to evaluate CF
+	            # Note: This may not work for all CFs without a mesh context
+	            B_value = cf(ngsolve.mesh.MakeIntegrationPoint(x_ngs, y_ngs, z_ngs))
+
+	            if hasattr(B_value, '__len__') and len(B_value) >= 3:
+	                return [float(B_value[0]), float(B_value[1]), float(B_value[2])]
+	            elif hasattr(B_value, '__len__'):
+	                # Scalar or less than 3 components
+	                return [0.0, 0.0, float(B_value[0]) if len(B_value) > 0 else 0.0]
+	            else:
+	                # Scalar CF
+	                return [0.0, 0.0, float(B_value)]
+
+	        except Exception as e:
+	            print(f"Warning: CF evaluation failed at ({x_ngs}, {y_ngs}, {z_ngs}): {e}")
+	            print("Returning zero field. Consider using create_analytical_field() instead.")
+	            return [0.0, 0.0, 0.0]
+
+	    return rad.ObjBckgCF(cf_wrapper)
+
+	elif callable(cf):
+	    # Python callable
+	    def wrapper(coords):
+	        """
+	        Wrapper for Python function with unit conversion.
+
+	        Args:
+	            coords: [x, y, z] in mm (Radia units)
+
+	        Returns:
+	            [Bx, By, Bz] in Tesla
+	        """
+	        if unit == 'm':
+	            x_m = coords[0] / 1000.0
+	            y_m = coords[1] / 1000.0
+	            z_m = coords[2] / 1000.0
+	            return cf(x_m, y_m, z_m)
+	        else:  # unit == 'mm'
+	            return cf(coords[0], coords[1], coords[2])
+
+	    return rad.ObjBckgCF(wrapper)
+
+	else:
+	    raise TypeError("cf must be NGSolve CoefficientFunction or Python callable")
+
+
+def create_analytical_field(field_func, unit='mm'):
+	"""
+	Create background field from analytical Python function.
+
+	Parameters
+	----------
+	field_func : callable
+	    Python function: [Bx, By, Bz] = field_func(x, y, z)
+	    Coordinates in specified units
+	unit : str, optional
+	    Unit of coordinates: 'm' or 'mm'
+	    Default: 'mm' (Radia internal units)
+
+	Returns
+	-------
+	int
+	    Radia object key for the field source
+
+	Examples
+	--------
+	>>> # Quadrupole field
+	>>> def quadrupole_field(x, y, z):
+	...     gradient = 10.0  # T/m
+	...     Bx = gradient * y / 1000  # Convert mm to m for gradient
+	...     By = gradient * x / 1000
+	...     Bz = 0.0
+	...     return [Bx, By, Bz]
+	>>>
+	>>> field_obj = create_analytical_field(quadrupole_field, unit='mm')
+	>>>
+	>>> # Use in Radia
+	>>> magnet = rad.ObjRecMag([0,0,0], [10,10,10], [0,0,1])
+	>>> container = rad.ObjCnt([magnet, field_obj])
+	>>> rad.Solve(container, 0.0001, 10000)
+
+	>>> # Linear gradient in z
+	>>> def gradient_field(x, y, z):
+	...     B0 = 1.0  # T
+	...     grad = 0.01  # T/mm
+	...     return [0, 0, B0 + grad * z]
+	>>>
+	>>> field_obj = create_analytical_field(gradient_field, unit='mm')
+	"""
+
+	def wrapper(coords):
+	    """
+	    Wrapper with unit conversion.
+
+	    Args:
+	        coords: [x, y, z] in mm (Radia units)
+
+	    Returns:
+	        [Bx, By, Bz] in Tesla
+	    """
+	    if unit == 'mm':
+	        return field_func(coords[0], coords[1], coords[2])
+	    else:  # unit == 'm'
+	        x_m = coords[0] / 1000.0
+	        y_m = coords[1] / 1000.0
+	        z_m = coords[2] / 1000.0
+	        return field_func(x_m, y_m, z_m)
+
+	return rad.ObjBckgCF(wrapper)
+
+
+def create_uniform_field(Bx, By, Bz):
+	"""
+	Create uniform background field (alternative to rad.ObjBckg).
+
+	Parameters
+	----------
+	Bx, By, Bz : float
+	    Uniform field components in Tesla
+
+	Returns
+	-------
+	int
+	    Radia object key
+
+	Examples
+	--------
+	>>> # Equivalent to rad.ObjBckg([0, 0, 1.0])
+	>>> field_obj = create_uniform_field(0, 0, 1.0)
+
+	Notes
+	-----
+	This is provided for completeness. For uniform fields,
+	rad.ObjBckg() is more efficient.
+	"""
+
+	def uniform(x, y, z):
+	    return [Bx, By, Bz]
+
+	return create_analytical_field(uniform, unit='mm')
+
+
+# Predefined field templates
+
+def dipole_field(moment, position=(0, 0, 0), unit='m'):
+	"""
+	Create magnetic dipole field.
+
+	Parameters
+	----------
+	moment : array_like
+	    Magnetic dipole moment [mx, my, mz] in A·m²
+	position : array_like, optional
+	    Dipole position [x0, y0, z0] in specified units
+	    Default: (0, 0, 0)
+	unit : str, optional
+	    Unit of coordinates: 'm' or 'mm'
+	    Default: 'm'
+
+	Returns
+	-------
+	int
+	    Radia object key
+
+	Examples
+	--------
+	>>> # Dipole at origin with moment in z
+	>>> field_obj = dipole_field([0, 0, 1.0], unit='m')
+
+	Notes
+	-----
+	B(r) = (μ₀/4π) * (3(m·r)r/r⁵ - m/r³)
+	"""
+
+	m = np.array(moment, dtype=float)
+	r0 = np.array(position, dtype=float)
+	mu0_4pi = 1e-7  # T·m/A
+
+	def dipole(x, y, z):
+	    # Position relative to dipole
+	    if unit == 'm':
+	        r = np.array([x - r0[0], y - r0[1], z - r0[2]])
+	    else:  # mm
+	        r = np.array([(x - r0[0])/1000, (y - r0[1])/1000, (z - r0[2])/1000])
+
+	    r_mag = np.linalg.norm(r)
+
+	    if r_mag < 1e-10:
+	        # Avoid singularity at dipole location
+	        return [0.0, 0.0, 0.0]
+
+	    r3 = r_mag**3
+	    r5 = r_mag**5
+
+	    m_dot_r = np.dot(m, r)
+
+	    B = mu0_4pi * (3 * m_dot_r * r / r5 - m / r3)
+
+	    return [float(B[0]), float(B[1]), float(B[2])]
+
+	return create_analytical_field(dipole, unit=unit)
+
+
+def solenoid_field(I, turns_per_m, radius, length, center=(0, 0, 0), unit='m'):
+	"""
+	Create ideal solenoid field (uniform inside, zero outside).
+
+	Parameters
+	----------
+	I : float
+	    Current in Amperes
+	turns_per_m : float
+	    Number of turns per meter
+	radius : float
+	    Solenoid radius in specified units
+	length : float
+	    Solenoid length in specified units
+	center : array_like, optional
+	    Solenoid center [x0, y0, z0]
+	unit : str, optional
+	    Unit: 'm' or 'mm'
+
+	Returns
+	-------
+	int
+	    Radia object key
+
+	Examples
+	--------
+	>>> # 1000 A·turns/m solenoid, 0.1m radius, 1m long
+	>>> field_obj = solenoid_field(10.0, 100, 0.1, 1.0, unit='m')
+	"""
+
+	mu0 = 4*np.pi*1e-7  # H/m
+	B_inside = mu0 * I * turns_per_m  # T
+
+	c = np.array(center, dtype=float)
+
+	def solenoid(x, y, z):
+	    # Check if inside solenoid
+	    if unit == 'm':
+	        r_perp = np.sqrt((x - c[0])**2 + (y - c[1])**2)
+	        z_rel = z - c[2]
+	    else:  # mm
+	        r_perp = np.sqrt((x - c[0])**2 + (y - c[1])**2) / 1000
+	        z_rel = (z - c[2]) / 1000
+	        radius_m = radius / 1000
+	        length_m = length / 1000
+
+	    if r_perp < radius and abs(z_rel) < length/2:
+	        return [0.0, 0.0, B_inside]
+	    else:
+	        return [0.0, 0.0, 0.0]
+
+	return create_analytical_field(solenoid, unit=unit)
+
+
+if __name__ == "__main__":
+	# Test examples
+	print("Radia-NGSolve Field Integration Module")
+	print("=======================================")
+	print()
+	print("Example usage:")
+	print()
+	print("1. Uniform field:")
+	print("   field = create_uniform_field(0, 0, 1.0)")
+	print()
+	print("2. Quadrupole field:")
+	print("   def quad(x, y, z):")
+	print("       g = 10.0  # T/m")
+	print("       return [g*y, g*x, 0]")
+	print("   field = create_analytical_field(quad, unit='m')")
+	print()
+	print("3. Dipole field:")
+	print("   field = dipole_field([0, 0, 1.0], unit='m')")
+	print()
+	print("4. With NGSolve CF:")
+	print("   from ngsolve import CF, x, y, z")
+	print("   B_cf = CF((0, 0, 1 + 0.01*x))")
+	print("   field = create_cf_field_source(B_cf, unit='m')")

python/radia_pyvista_viewer.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+"""
+PyVista-based viewer for Radia objects
+This is a modern alternative to rad.ObjDrwOpenGL()
+"""
+
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'dist'))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'build', 'lib', 'Release'))
+
+import radia as rad
+import numpy as np
+
+def view_radia_object(obj, plotter=None, show=True, color=None, opacity=1.0):
+	"""
+	View a Radia object using PyVista
+
+	Parameters:
+	-----------
+	obj : int
+		Radia object ID
+	plotter : pyvista.Plotter, optional
+		Existing plotter to add to (for combining multiple objects)
+	show : bool, default True
+		Whether to show the plotter immediately
+	color : str or list, optional
+		Color override (e.g., 'red', [1,0,0])
+	opacity : float, default 1.0
+		Opacity (0=transparent, 1=opaque)
+
+	Returns:
+	--------
+	plotter : pyvista.Plotter
+		The plotter object (can be reused)
+	"""
+	try:
+		import pyvista as pv
+	except ImportError:
+		print("ERROR: PyVista is not installed.")
+		print("Install it with: pip install pyvista")
+		return None
+
+	# Get VTK data from Radia
+	vtk_data = rad.ObjDrwVTK(obj, 'Axes->False')
+
+	if 'polygons' not in vtk_data:
+		print("ERROR: No polygon data found in Radia object")
+		return None
+
+	poly = vtk_data['polygons']
+
+	# Extract vertices (flatten x,y,z triplets)
+	vertices = np.array(poly['vertices']).reshape(-1, 3)
+
+	# Extract polygon connectivity
+	lengths = poly['lengths']
+	n_polys = len(lengths)
+
+	# Build faces array for PyVista
+	# PyVista format: [n_points, p0, p1, p2, ..., n_points, p0, p1, ...]
+	faces = []
+	offset = 0
+	for length in lengths:
+		faces.append(length)
+		for i in range(length):
+			faces.append(offset + i)
+		offset += length
+
+	faces = np.array(faces)
+
+	# Create PyVista mesh
+	mesh = pv.PolyData(vertices, faces)
+
+	# Create or use existing plotter
+	if plotter is None:
+		plotter = pv.Plotter()
+		plotter.add_axes()
+		plotter.add_text("Radia Object Viewer (PyVista)", position='upper_left', font_size=10)
+
+	# Determine color
+	if color is None:
+		# Use Radia's color if available
+		colors = poly.get('colors', None)
+		if colors is not None and len(colors) > 0:
+			# Use first color (all polygons typically same color)
+			rgb = colors[0:3]
+			# Radia uses -1 for default, convert to actual color
+			if rgb[0] < 0:
+				color = 'lightblue'
+			else:
+				color = rgb
+
+	# Add mesh to plotter
+	plotter.add_mesh(mesh, color=color, opacity=opacity, show_edges=True,
+	                 edge_color='black', line_width=0.5)
+
+	if show:
+		plotter.show()
+
+	return plotter
+
+
+def view_radia_vtk_file(filename):
+	"""
+	View a VTK file generated by exportGeometryToVTK
+
+	Parameters:
+	-----------
+	filename : str
+		Path to .vtk file
+	"""
+	try:
+		import pyvista as pv
+	except ImportError:
+		print("ERROR: PyVista is not installed.")
+		print("Install it with: pip install pyvista")
+		return
+
+	# Read VTK file
+	mesh = pv.read(filename)
+
+	# Create plotter
+	plotter = pv.Plotter()
+	plotter.add_axes()
+	plotter.add_text(f"Viewing: {os.path.basename(filename)}",
+	                 position='upper_left', font_size=10)
+
+	# Add mesh
+	plotter.add_mesh(mesh, show_edges=True, edge_color='black', line_width=0.5)
+
+	# Show
+	plotter.show()
+
+
+if __name__ == '__main__':
+	print("="*60)
+	print("Radia PyVista Viewer Demo")
+	print("="*60)
+
+	# Check if PyVista is available
+	try:
+		import pyvista as pv
+		print(f"\nPyVista version: {pv.__version__}")
+	except ImportError:
+		print("\nERROR: PyVista is not installed.")
+		print("Install it with:")
+		print("  pip install pyvista")
+		sys.exit(1)
+
+	# Create a simple test object
+	print("\nCreating test objects...")
+
+	# Arc current
+	g1 = rad.ObjArcCur([0,0,0], [95, 105], [0, 2*np.pi], 20, 36, 1e6/20/10, "man")
+
+	# Rectangular magnet
+	g2 = rad.ObjRecMag([0,0,0], [30,30,10], [0,0,1])
+
+	# Container
+	g = rad.ObjCnt([g1, g2])
+
+	print("Objects created. Opening PyVista viewer...")
+	print("\nControls:")
+	print("  - Left click + drag: Rotate")
+	print("  - Right click + drag: Pan")
+	print("  - Scroll wheel: Zoom")
+	print("  - 'q': Quit")
+
+	# View the object
+	view_radia_object(g)
+
+	print("\nViewer closed.")

python/radia_vtk_export.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Radia VTK Export Utilities
+
+Functions for exporting Radia geometry to VTK format for visualization
+in ParaView and other VTK-compatible tools.
+"""
+
+import radia as rad
+import csv
+from itertools import accumulate
+
+def chunks(lst, n):
+	"""
+	Yield successive n-sized chunks from a list.
+
+	Args:
+		lst: List to be chunked
+		n: Chunk size
+
+	Yields:
+		Chunks of size n from the input list
+	"""
+	for i in range(0, len(lst), n):
+		yield lst[i:i + n]
+
+def exportGeometryToVTK(obj, fileName='radia_Geometry'):
+	"""
+	Export Radia object geometry to VTK Legacy format file.
+
+	Writes the geometry of a Radia object to a .vtk file for visualization
+	in ParaView. The format is VTK Legacy (ASCII), consisting of polygons only.
+
+	Args:
+		obj: Radia object ID (integer)
+		fileName: Output filename without extension (default: 'radia_Geometry')
+
+	Output:
+		Creates fileName.vtk in the current directory
+
+	Example:
+		>>> import radia as rad
+		>>> from radia_vtk_export import exportGeometryToVTK
+		>>> mag = rad.ObjRecMag([0,0,0], [10,10,10], [0,0,1])
+		>>> exportGeometryToVTK(mag, 'my_magnet')
+	"""
+	
+	vtkData = rad.ObjDrwVTK(obj, 'Axes->False')
+
+	lengths = vtkData['polygons']['lengths']
+	nPoly = len(lengths)
+	offsets = list(accumulate(lengths))
+	offsets.insert(0, 0) # prepend list with a zero
+	points = vtkData['polygons']['vertices']
+	nPnts = int(len(points)/3)
+
+	# format the points array to be floats rather than double
+	points = [round(num/1000.0, 8) for num in points]		
+	# Note: Converted from mm (Radia units) to m
+	# define the connectivity list
+	conn = list(range(nPnts)) 
+	# define colours array
+	colors = vtkData['polygons']['colors']
+
+	# pre-process the output lists to have chunkLength items per line
+	chunkLength = 9 # this writes 9 numbers per line (9 is the number used in Paraview if data is saved as the VTK Legacy format)
+	offsets = list(chunks(offsets, chunkLength))
+	points = list(chunks(points, chunkLength))
+	conn = list(chunks(conn, chunkLength))
+	colors = list(chunks(colors, chunkLength))
+
+	# write the data to file
+	with open(fileName + ".vtk", "w", newline="") as f:
+		f.write('# vtk DataFile Version 5.1\n')
+		f.write('vtk output\nASCII\nDATASET POLYDATA\n')
+		f.write('POINTS ' + str(nPnts) + ' float\n')
+		writer = csv.writer(f, delimiter=" ")
+		writer.writerows(points)
+		f.write('\n')
+		f.write('POLYGONS ' + str(nPoly+1) + ' ' + str(nPnts) + '\n')
+		f.write('OFFSETS vtktypeint64\n')
+		writer.writerows(offsets)
+		f.write('CONNECTIVITY vtktypeint64\n')  
+		writer.writerows(conn)
+		f.write('\n')
+		f.write('CELL_DATA ' + str(nPoly) + '\n')
+		f.write('COLOR_SCALARS Radia_colours 3\n')
+		writer.writerows(colors)
+
+	print(f"VTK file exported: {fileName}.vtk")
+	print(f"  Polygons: {nPoly}")
+	print(f"  Points: {nPnts}")
+
+
+if __name__ == '__main__':
+	"""
+	Demo: Export a simple Radia geometry to VTK format
+	"""
+	import sys
+	import os
+
+	# Add build directory to path
+	sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'build', 'lib', 'Release'))
+	sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'dist'))
+
+	print("=" * 60)
+	print("Radia VTK Export Demo")
+	print("=" * 60)
+
+	# Create a simple test geometry
+	print("\nCreating test geometry...")
+
+	# Rectangular magnet
+	mag = rad.ObjRecMag([0, 0, 0], [30, 30, 10], [0, 0, 1])
+
+	# Cylindrical magnet
+	cyl = rad.ObjCylMag([50, 0, 0], 15, 20, 16, 'z', [0, 0, 1])
+
+	# Container
+	container = rad.ObjCnt([mag, cyl])
+
+	# Export to VTK
+	output_file = 'radia_demo_geometry'
+	print(f"\nExporting geometry to {output_file}.vtk...")
+	exportGeometryToVTK(container, output_file)
+
+	print("\n" + "=" * 60)
+	print("Export complete!")
+	print("\nTo view in ParaView:")
+	print(f"  1. Open ParaView")
+	print(f"  2. File → Open → {output_file}.vtk")
+	print(f"  3. Click 'Apply' in the Properties panel")
+	print("=" * 60)

{radia-1.0.8.dist-info → radia-1.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: radia
-Version: 1.0.8
+Version: 1.0.9
 Summary: Radia 3D Magnetostatics with NGSolve Integration and OpenMP Parallelization
 Home-page: https://github.com/ksugahar/Radia_NGSolve
 Author: Pascal Elleaume

radia-1.0.9.dist-info/RECORD

@@ -0,0 +1,13 @@
+python/__init__.py,sha256=o4JtQw0g5WcRpQAUi97FgL5BIUAlfMBrn4442GGdGuc,47
+python/nastran_reader.py,sha256=r4K2LJvHBtvBumbinbiQeyPA42iyvxNyAd6Y05lxeZs,10035
+python/rad_ngsolve.pyd,sha256=pfLmNoFQtTqS_Uzey4v3WWwD_KpqrOjuZeXuK1_8LEs,576512
+python/radia.pyd,sha256=aSCAxppUbllAM0AJPOKvHxBQ_Iio61U0uiosZevirOk,1820672
+python/radia_coil_builder.py,sha256=nQkiAbfhueNvvxUARHdPD0C68ImidHmUQv_q4RsImeY,11253
+python/radia_ngsolve_field.py,sha256=suJr4wacfYFKOkyV-5AQuHWnW5rtUMb0gSSjq8VRSXc,10166
+python/radia_pyvista_viewer.py,sha256=JS33Mx4azGI7hUX0bzefc6zJfhv6qfRjM3Kl1bE9Mjs,4275
+python/radia_vtk_export.py,sha256=UbPvo7ftHYLREz6TSpWrpLw7JesFhMA58-22R63HHH4,3997
+radia-1.0.9.dist-info/licenses/LICENSE,sha256=Db6_UKUk2lyGv0e4MMLNG74LJ-aep64N2FEYQ8eA9DU,29796
+radia-1.0.9.dist-info/METADATA,sha256=iN0Z0S9aCOvMKldmXLbpDseSBciwPOarHz84E01fLgE,12323
+radia-1.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+radia-1.0.9.dist-info/top_level.txt,sha256=J-z0poNcsv31IHB413--iOY8LoHBKiTHeybHX3abokI,7
+radia-1.0.9.dist-info/RECORD,,