radia 1.2.0__tar.gz → 1.3.2__tar.gz

{radia-1.2.0/src/radia.egg-info → radia-1.3.2}/PKG-INFO

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

{radia-1.2.0 → radia-1.3.2}/docs/README.md

@@ -34,6 +34,11 @@ This folder contains the official documentation for Radia.
 
 ## Additional Resources
 
+### Internal Documentation (For Maintainers)
+Design documents and implementation analysis are in [../internal/](../internal/):
+- [design/](../internal/design/) - Architecture decisions, implementation proposals
+- [analysis/](../internal/analysis/) - Performance analysis, bottleneck investigations
+
 ### Development Notes
 Implementation notes, performance analysis, and troubleshooting are in [../dev/notes/](../dev/notes/):
 - Implementation details (directory structure, conversion reports)

{radia-1.2.0 → radia-1.3.2}/examples/NGSolve_Integration/benchmark_gridfunction_set.py

@@ -81,8 +81,9 @@ for radia_cfg in radia_configs:
 
 	# Create Radia magnet geometry
 	rad.UtiDelAll()
+	rad.FldUnits('m')  # Set units to meters
 
-	cube_size = 100.0  # mm
+	cube_size = 0.100  # meters
 	elem_size = cube_size / n
 	mag_value = 1.2  # T
 
@@ -109,7 +110,7 @@ for radia_cfg in radia_configs:
 		print(f"  {'-'*76}")
 
 		# Create NGSolve mesh
-		box_size_m = cube_size * 2.0 / 1000  # mm to m
+		box_size_m = cube_size * 2.0  # meters
 		geo = Box(
 			Pnt(-box_size_m/2, -box_size_m/2, -box_size_m/2),
 			Pnt( box_size_m/2,  box_size_m/2,  box_size_m/2)

radia-1.3.2/examples/NGSolve_Integration/demo_batch_evaluation.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python
+"""
+Demonstration: Batch evaluation for H-matrix acceleration
+
+Shows the benefit of batching all evaluation points together
+versus element-by-element evaluation.
+
+Current limitation:
+- NGSolve's GridFunction.Set() calls CoefficientFunction element-by-element
+- Each call has only ~10-20 points (one element's integration points)
+- H-matrix overhead >> computation time for such small batches
+- No speedup observed
+
+Proposed solution:
+- Collect ALL integration points from ALL elements
+- Evaluate in ONE batch call (1000s of points)
+- H-matrix speedup is significant for large batches
+- Expected: 10-100x speedup for N>1000
+
+This script demonstrates the concept and measures potential speedup.
+"""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../build/Release'))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../src/python'))
+
+import radia as rad
+import numpy as np
+import time
+
+try:
+    from ngsolve import *
+    from netgen.occ import *
+    import rad_ngsolve
+except ImportError:
+    print("NGSolve not available")
+    sys.exit(0)
+
+print("="*70)
+print("Batch Evaluation Demo for H-Matrix Acceleration")
+print("="*70)
+
+# Set Radia units to meters
+rad.FldUnits('m')
+
+# Create Radia magnet
+rad.UtiDelAll()
+n = 5  # 5x5x5 = 125 elements
+cube_size = 0.100
+elem_size = cube_size / n
+
+print(f"\n[1] Creating magnet: {n}x{n}x{n} = {n**3} elements")
+elements = []
+for i in range(n):
+    for j in range(n):
+        for k in range(n):
+            x = (i - n/2 + 0.5) * elem_size
+            y = (j - n/2 + 0.5) * elem_size
+            z = (k - n/2 + 0.5) * elem_size
+            elem = rad.ObjRecMag([x, y, z], [elem_size, elem_size, elem_size],
+                                 [0, 0, 1.2])
+            elements.append(elem)
+
+magnet = rad.ObjCnt(elements)
+
+# Create mesh
+print(f"\n[2] Creating NGSolve mesh")
+box = Box((0.015, 0.015, 0.015), (0.063, 0.063, 0.063))
+mesh = Mesh(OCCGeometry(box).GenerateMesh(maxh=0.010))
+print(f"    Mesh: {mesh.nv} vertices, {mesh.ne} elements")
+
+# Create finite element space
+fes = HCurl(mesh, order=2)
+gf = GridFunction(fes)
+print(f"    FE space: {fes.ndof} DOFs")
+
+# Estimate number of integration points
+# For HCurl order=2, typically 10-15 points per element
+points_per_elem = 15  # Estimate
+total_points = mesh.ne * points_per_elem
+print(f"    Estimated integration points: ~{total_points}")
+
+print("\n" + "="*70)
+print("MEASUREMENT 1: Element-by-element evaluation (current method)")
+print("="*70)
+
+# Standard GridFunction.Set() with H-matrix
+rad.SetHMatrixFieldEval(1, 1e-6)
+cf_standard = rad_ngsolve.RadiaField(magnet, 'b')
+
+print(f"\n[3a] Measuring GridFunction.Set() with H-matrix...")
+print(f"     (Element-by-element: {mesh.ne} calls, ~{points_per_elem} points/call)")
+
+t0 = time.time()
+gf.Set(cf_standard)
+t_standard = time.time() - t0
+
+print(f"     Time: {t_standard*1000:.1f} ms")
+print(f"     Average per element: {t_standard*1000/mesh.ne:.2f} ms")
+
+print("\n" + "="*70)
+print("MEASUREMENT 2: Single batch evaluation (proposed method)")
+print("="*70)
+
+# Simulate batch evaluation: collect all vertices and evaluate once
+print(f"\n[3b] Simulating batch evaluation...")
+print(f"     (Single batch: 1 call, {mesh.nv} points)")
+
+# Collect all vertex positions
+points = []
+for v in mesh.vertices:
+    pt = v.point
+    points.append([pt[0], pt[1], pt[2]])
+
+# Single batch evaluation
+t0 = time.time()
+field_values = rad.FldBatch(magnet, 'b', points, 1)  # use_hmatrix=1
+t_batch = time.time() - t0
+
+print(f"     Time: {t_batch*1000:.1f} ms")
+print(f"     Average per point: {t_batch*1e6/len(points):.2f} us")
+
+print("\n" + "="*70)
+print("ANALYSIS")
+print("="*70)
+
+# Calculate actual points evaluated in standard method
+# Each element's integration rule has multiple points
+actual_eval_points = total_points
+
+print(f"\nEstimated evaluation points:")
+print(f"  Standard method: ~{actual_eval_points} points")
+print(f"  Batch method:     {len(points)} points (vertices only)")
+
+print(f"\nTime comparison:")
+print(f"  Standard (element-by-element): {t_standard*1000:8.1f} ms")
+print(f"  Batch (single call):           {t_batch*1000:8.1f} ms")
+
+speedup = t_standard / t_batch
+print(f"\nObserved speedup: {speedup:.2f}x")
+
+print(f"\nWhy the speedup is limited:")
+print(f"  - Standard method evaluates ~{actual_eval_points} integration points")
+print(f"  - Batch method evaluates only {len(points)} vertices")
+print(f"  - Not a fair comparison!")
+
+print(f"\nTrue batch optimization requires:")
+print(f"  1. Collect ALL integration points (~{actual_eval_points})")
+print(f"  2. Evaluate in ONE batch call")
+print(f"  3. Map results back to GridFunction DOFs")
+print(f"  4. This would give true {speedup:.1f}-{speedup*2:.1f}x speedup")
+
+print("\n" + "="*70)
+print("CONCLUSION")
+print("="*70)
+
+print(f"""
+Current situation:
+- GridFunction.Set() calls Evaluate() {mesh.ne} times
+- Each call evaluates ~{points_per_elem} points
+- H-matrix overhead dominates for small batches
+- Total time: {t_standard*1000:.1f} ms
+
+Optimized approach (requires C++ implementation):
+- Collect all ~{actual_eval_points} integration points
+- Single FldBatch() call
+- Full H-matrix acceleration
+- Expected time: ~{t_batch*actual_eval_points/len(points):.1f} ms
+- Expected speedup: ~{t_standard/(t_batch*actual_eval_points/len(points)):.1f}x
+
+Implementation path:
+1. Add PrepareCache() method to RadiaFieldCF (C++)
+2. PrepareCache() collects all mesh integration points
+3. PrepareCache() calls FldBatch() once
+4. Evaluate() returns cached values
+5. User calls PrepareCache(mesh) before gf.Set(cf)
+""")
+
+print("="*70)
+
+rad.UtiDelAll()
+

{radia-1.2.0 → radia-1.3.2}/examples/NGSolve_Integration/demo_field_types.py

@@ -1,193 +1,197 @@
-"""
-Radia Field Types Demo - NGSolve Integration
-
-This script demonstrates how to use the new unified RadiaField interface
-to access different physical field quantities:
-- 'b': Magnetic flux density (Tesla)
-- 'h': Magnetic field (A/m)
-- 'a': Vector potential (T*m)
-- 'm': Magnetization (A/m)
-
-Usage:
-	python demo_field_types.py
-
-
-Date: 2025-11-01
-"""
-
-import sys
-sys.path.insert(0, r"S:\radia\01_GitHub\build\Release")
-sys.path.insert(0, r"S:\radia\01_GitHub\dist")
-
-from ngsolve import *
-from netgen.csg import CSGeometry, OrthoBrick, Pnt
-import numpy as np
-import radia as rad
-import rad_ngsolve
-
-print("=" * 70)
-print("Radia Field Types Demo")
-print("=" * 70)
-
-# ============================================================================
-# Step 1: Create Radia Magnet Geometry
-# ============================================================================
-
-print("\n[Step 1] Creating Radia Magnet")
-print("-" * 70)
-
-magnet_center = [0, 0, 0]
-magnet_size = [20, 20, 30]
-
-magnet = rad.ObjRecMag(magnet_center, magnet_size, [0, 0, 1.2])
-rad.MatApl(magnet, rad.MatPM(1.2, 900000, [0, 0, 1]))  # NdFeB
-rad.Solve(magnet, 0.0001, 10000)
-
-print(f"Magnet created: object #{magnet}")
-print(f"  Center: {magnet_center} mm")
-print(f"  Size: {magnet_size} mm")
-print(f"  Material: NdFeB, Br = 1.2 T")
-
-# ============================================================================
-# Step 2: Create CoefficientFunctions for Different Field Types
-# ============================================================================
-
-print("\n[Step 2] Creating CoefficientFunctions for All Field Types")
-print("-" * 70)
-
-# Method 1: New unified interface (recommended)
-B_cf = rad_ngsolve.RadiaField(magnet, 'b')  # Magnetic flux density
-H_cf = rad_ngsolve.RadiaField(magnet, 'h')  # Magnetic field
-A_cf = rad_ngsolve.RadiaField(magnet, 'a')  # Vector potential
-M_cf = rad_ngsolve.RadiaField(magnet, 'm')  # Magnetization
-
-print(f"Created CoefficientFunctions:")
-print(f"  B (flux density):  {type(B_cf).__name__}, field_type='{B_cf.field_type}'")
-print(f"  H (magnetic field): {type(H_cf).__name__}, field_type='{H_cf.field_type}'")
-print(f"  A (vector potential): {type(A_cf).__name__}, field_type='{A_cf.field_type}'")
-print(f"  M (magnetization):  {type(M_cf).__name__}, field_type='{M_cf.field_type}'")
-
-# ============================================================================
-# Step 3: Create 3D Mesh
-# ============================================================================
-
-print("\n[Step 3] Creating 3D Mesh")
-print("-" * 70)
-
-geo = CSGeometry()
-geo.Add(OrthoBrick(Pnt(-0.05, -0.05, -0.05), Pnt(0.05, 0.05, 0.05)))
-mesh = Mesh(geo.GenerateMesh(maxh=0.01))
-
-print(f"3D Mesh generated:")
-print(f"  Elements: {mesh.ne}")
-print(f"  Vertices: {mesh.nv}")
-print(f"  Domain: [-0.05, 0.05] m = [-50, 50] mm")
-
-# ============================================================================
-# Step 4: Evaluate Fields at Test Points
-# ============================================================================
-
-print("\n[Step 4] Field Evaluation at Test Points")
-print("-" * 70)
-
-test_points = [
-	(0.000, 0.000, 0.000),	# 0mm (center)
-	(0.000, 0.000, 0.020),  # 20mm (above magnet)
-	(0.000, 0.000, 0.040),  # 40mm (far from magnet)
-]
-
-print("\n" + "=" * 70)
-print("Field Values at Different Points")
-print("=" * 70)
-
-for pt in test_points:
-	pt_mm = [pt[0]*1000, pt[1]*1000, pt[2]*1000]
-	mesh_pt = mesh(*pt)
-
-	print(f"\nPoint: {pt} m = {pt_mm} mm")
-
-	# B field (Tesla)
-	B_val = B_cf(mesh_pt)
-	print(f"  B (flux density):    Bx={B_val[0]:8.6f}, By={B_val[1]:8.6f}, Bz={B_val[2]:8.6f} T")
-
-	# H field (A/m)
-	H_val = H_cf(mesh_pt)
-	print(f"  H (magnetic field):  Hx={H_val[0]:8.2f}, Hy={H_val[1]:8.2f}, Hz={H_val[2]:8.2f} A/m")
-
-	# A field (T*m)
-	A_val = A_cf(mesh_pt)
-	print(f"  A (vector potential): Ax={A_val[0]:8.6f}, Ay={A_val[1]:8.6f}, Az={A_val[2]:8.6f} T*m")
-
-	# M field (A/m)
-	M_val = M_cf(mesh_pt)
-	print(f"  M (magnetization):   Mx={M_val[0]:8.2f}, My={M_val[1]:8.2f}, Mz={M_val[2]:8.2f} A/m")
-
-# ============================================================================
-# Step 5: Compare with Radia Direct Evaluation
-# ============================================================================
-
-print("\n" + "=" * 70)
-print("Comparison with Radia Direct Evaluation")
-print("=" * 70)
-
-pt_mm = [0, 0, 0]  # Center point in mm
-mesh_pt = mesh(0, 0, 0)
-
-print(f"\nAt center ({pt_mm} mm):")
-
-# Radia direct
-B_radia = rad.Fld(magnet, 'b', pt_mm)
-H_radia = rad.Fld(magnet, 'h', pt_mm)
-A_radia = rad.Fld(magnet, 'a', pt_mm)
-M_radia = rad.Fld(magnet, 'm', pt_mm)
-
-# NGSolve CoefficientFunction
-B_ngsolve = B_cf(mesh_pt)
-H_ngsolve = H_cf(mesh_pt)
-A_ngsolve = A_cf(mesh_pt)
-M_ngsolve = M_cf(mesh_pt)
-
-# Compare
-print(f"\nB field:")
-print(f"  Radia:   Bz = {B_radia[2]:.6f} T")
-print(f"  NGSolve: Bz = {B_ngsolve[2]:.6f} T")
-print(f"  Error:   {abs(B_radia[2] - B_ngsolve[2]):.2e} T")
-
-print(f"\nH field:")
-print(f"  Radia:   Hz = {H_radia[2]:.2f} A/m")
-print(f"  NGSolve: Hz = {H_ngsolve[2]:.2f} A/m")
-print(f"  Error:   {abs(H_radia[2] - H_ngsolve[2]):.2e} A/m")
-
-print(f"\nA field:")
-print(f"  Radia:   |A| = {np.linalg.norm(A_radia):.6e} T*m")
-print(f"  NGSolve: |A| = {np.linalg.norm(A_ngsolve):.6e} T*m")
-
-print(f"\nM field (Magnetization):")
-print(f"  Radia:   Mz = {M_radia[2]:.2f} A/m")
-print(f"  NGSolve: Mz = {M_ngsolve[2]:.2f} A/m")
-print(f"  Error:   {abs(M_radia[2] - M_ngsolve[2]):.2e} A/m")
-
-# ============================================================================
-# Summary
-# ============================================================================
-
-print("\n" + "=" * 70)
-print("Summary")
-print("=" * 70)
-
-print("\nNew Unified Interface:")
-print("  rad_ngsolve.RadiaField(radia_obj, field_type)")
-print("\nField types:")
-print("  'b' - Magnetic flux density B (Tesla)")
-print("  'h' - Magnetic field H (A/m)")
-print("  'a' - Vector potential A (T*m)")
-print("  'm' - Magnetization M (A/m)")
-
-print("\nRecommendation:")
-print("  Use the new RadiaField interface for all new code.")
-print("  Legacy interfaces (RadBfield, RadHfield, etc.) remain")
-print("  supported for backward compatibility.")
-
-print("\n" + "=" * 70)
-print("Complete")
-print("=" * 70)
+"""
+Radia Field Types Demo - NGSolve Integration
+
+This script demonstrates how to use the new unified RadiaField interface
+to access different physical field quantities:
+- 'b': Magnetic flux density (Tesla)
+- 'h': Magnetic field (A/m)
+- 'a': Vector potential (T*m)
+- 'm': Magnetization (A/m)
+
+Usage:
+	python demo_field_types.py
+
+
+Date: 2025-11-01
+"""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../build/Release'))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../src/python'))
+
+from ngsolve import *
+from netgen.csg import CSGeometry, OrthoBrick, Pnt
+import numpy as np
+import radia as rad
+import rad_ngsolve
+
+print("=" * 70)
+print("Radia Field Types Demo")
+print("=" * 70)
+
+# Set Radia to use meters (required for NGSolve integration)
+rad.FldUnits('m')
+
+# ============================================================================
+# Step 1: Create Radia Magnet Geometry
+# ============================================================================
+
+print("\n[Step 1] Creating Radia Magnet")
+print("-" * 70)
+
+magnet_center = [0, 0, 0]  # meters
+magnet_size = [0.020, 0.020, 0.030]  # meters (20mm x 20mm x 30mm)
+
+magnet = rad.ObjRecMag(magnet_center, magnet_size, [0, 0, 1.2])
+rad.MatApl(magnet, rad.MatPM(1.2, 900000, [0, 0, 1]))  # NdFeB
+rad.Solve(magnet, 0.0001, 10000)
+
+print(f"Magnet created: object #{magnet}")
+print(f"  Center: {magnet_center} m")
+print(f"  Size: {magnet_size} m")
+print(f"  Material: NdFeB, Br = 1.2 T")
+
+# ============================================================================
+# Step 2: Create CoefficientFunctions for Different Field Types
+# ============================================================================
+
+print("\n[Step 2] Creating CoefficientFunctions for All Field Types")
+print("-" * 70)
+
+# Method 1: New unified interface (recommended)
+B_cf = rad_ngsolve.RadiaField(magnet, 'b')  # Magnetic flux density
+H_cf = rad_ngsolve.RadiaField(magnet, 'h')  # Magnetic field
+A_cf = rad_ngsolve.RadiaField(magnet, 'a')  # Vector potential
+M_cf = rad_ngsolve.RadiaField(magnet, 'm')  # Magnetization
+
+print(f"Created CoefficientFunctions:")
+print(f"  B (flux density):  {type(B_cf).__name__}, field_type='{B_cf.field_type}'")
+print(f"  H (magnetic field): {type(H_cf).__name__}, field_type='{H_cf.field_type}'")
+print(f"  A (vector potential): {type(A_cf).__name__}, field_type='{A_cf.field_type}'")
+print(f"  M (magnetization):  {type(M_cf).__name__}, field_type='{M_cf.field_type}'")
+
+# ============================================================================
+# Step 3: Create 3D Mesh
+# ============================================================================
+
+print("\n[Step 3] Creating 3D Mesh")
+print("-" * 70)
+
+geo = CSGeometry()
+geo.Add(OrthoBrick(Pnt(-0.05, -0.05, -0.05), Pnt(0.05, 0.05, 0.05)))
+mesh = Mesh(geo.GenerateMesh(maxh=0.01))
+
+print(f"3D Mesh generated:")
+print(f"  Elements: {mesh.ne}")
+print(f"  Vertices: {mesh.nv}")
+print(f"  Domain: [-0.05, 0.05] m = [-50, 50] mm")
+
+# ============================================================================
+# Step 4: Evaluate Fields at Test Points
+# ============================================================================
+
+print("\n[Step 4] Field Evaluation at Test Points")
+print("-" * 70)
+
+test_points = [
+	(0.000, 0.000, 0.000),	# 0m (center)
+	(0.000, 0.000, 0.020),  # 0.020m (above magnet)
+	(0.000, 0.000, 0.040),  # 0.040m (far from magnet)
+]
+
+print("\n" + "=" * 70)
+print("Field Values at Different Points")
+print("=" * 70)
+
+for pt in test_points:
+	pt_m = pt
+	mesh_pt = mesh(*pt)
+
+	print(f"\nPoint: {pt} m")
+
+	# B field (Tesla)
+	B_val = B_cf(mesh_pt)
+	print(f"  B (flux density):    Bx={B_val[0]:8.6f}, By={B_val[1]:8.6f}, Bz={B_val[2]:8.6f} T")
+
+	# H field (A/m)
+	H_val = H_cf(mesh_pt)
+	print(f"  H (magnetic field):  Hx={H_val[0]:8.2f}, Hy={H_val[1]:8.2f}, Hz={H_val[2]:8.2f} A/m")
+
+	# A field (T*m)
+	A_val = A_cf(mesh_pt)
+	print(f"  A (vector potential): Ax={A_val[0]:8.6f}, Ay={A_val[1]:8.6f}, Az={A_val[2]:8.6f} T*m")
+
+	# M field (A/m)
+	M_val = M_cf(mesh_pt)
+	print(f"  M (magnetization):   Mx={M_val[0]:8.2f}, My={M_val[1]:8.2f}, Mz={M_val[2]:8.2f} A/m")
+
+# ============================================================================
+# Step 5: Compare with Radia Direct Evaluation
+# ============================================================================
+
+print("\n" + "=" * 70)
+print("Comparison with Radia Direct Evaluation")
+print("=" * 70)
+
+pt_m = [0, 0, 0]  # Center point in meters
+mesh_pt = mesh(0, 0, 0)
+
+print(f"\nAt center ({pt_m} m):")
+
+# Radia direct
+B_radia = rad.Fld(magnet, 'b', pt_m)
+H_radia = rad.Fld(magnet, 'h', pt_m)
+A_radia = rad.Fld(magnet, 'a', pt_m)
+M_radia = rad.Fld(magnet, 'm', pt_m)
+
+# NGSolve CoefficientFunction
+B_ngsolve = B_cf(mesh_pt)
+H_ngsolve = H_cf(mesh_pt)
+A_ngsolve = A_cf(mesh_pt)
+M_ngsolve = M_cf(mesh_pt)
+
+# Compare
+print(f"\nB field:")
+print(f"  Radia:   Bz = {B_radia[2]:.6f} T")
+print(f"  NGSolve: Bz = {B_ngsolve[2]:.6f} T")
+print(f"  Error:   {abs(B_radia[2] - B_ngsolve[2]):.2e} T")
+
+print(f"\nH field:")
+print(f"  Radia:   Hz = {H_radia[2]:.2f} A/m")
+print(f"  NGSolve: Hz = {H_ngsolve[2]:.2f} A/m")
+print(f"  Error:   {abs(H_radia[2] - H_ngsolve[2]):.2e} A/m")
+
+print(f"\nA field:")
+print(f"  Radia:   |A| = {np.linalg.norm(A_radia):.6e} T*m")
+print(f"  NGSolve: |A| = {np.linalg.norm(A_ngsolve):.6e} T*m")
+
+print(f"\nM field (Magnetization):")
+print(f"  Radia:   Mz = {M_radia[2]:.2f} A/m")
+print(f"  NGSolve: Mz = {M_ngsolve[2]:.2f} A/m")
+print(f"  Error:   {abs(M_radia[2] - M_ngsolve[2]):.2e} A/m")
+
+# ============================================================================
+# Summary
+# ============================================================================
+
+print("\n" + "=" * 70)
+print("Summary")
+print("=" * 70)
+
+print("\nNew Unified Interface:")
+print("  rad_ngsolve.RadiaField(radia_obj, field_type)")
+print("\nField types:")
+print("  'b' - Magnetic flux density B (Tesla)")
+print("  'h' - Magnetic field H (A/m)")
+print("  'a' - Vector potential A (T*m)")
+print("  'm' - Magnetization M (A/m)")
+
+print("\nRecommendation:")
+print("  Use the new RadiaField interface for all new code.")
+print("  Legacy interfaces (RadBfield, RadHfield, etc.) remain")
+print("  supported for backward compatibility.")
+
+print("\n" + "=" * 70)
+print("Complete")
+print("=" * 70)