radia 1.0.9__tar.gz → 1.0.10__tar.gz

{radia-1.0.9/src/radia.egg-info → radia-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: radia
-Version: 1.0.9
+Version: 1.0.10
 Summary: Radia 3D Magnetostatics with NGSolve Integration and OpenMP Parallelization
 Home-page: https://github.com/ksugahar/Radia_NGSolve
 Author: Pascal Elleaume
@@ -150,7 +150,7 @@ import rad_ngsolve
 
 # Create Radia magnet
 magnet = rad.ObjRecMag([0,0,0], [20,20,20], [0,0,1.2])  # mm units
-rad.MatApl(magnet, rad.MatStd('NdFeB', 1.2))
+rad.MatApl(magnet, rad.MatLin([0.06, 0.17], [0,0,1.2]))  # NdFeB
 rad.Solve(magnet, 0.0001, 10000)
 
 # Create NGSolve CoefficientFunction for different field types

{radia-1.0.9 → radia-1.0.10}/README.md

@@ -110,7 +110,7 @@ import rad_ngsolve
 
 # Create Radia magnet
 magnet = rad.ObjRecMag([0,0,0], [20,20,20], [0,0,1.2])  # mm units
-rad.MatApl(magnet, rad.MatStd('NdFeB', 1.2))
+rad.MatApl(magnet, rad.MatLin([0.06, 0.17], [0,0,1.2]))  # NdFeB
 rad.Solve(magnet, 0.0001, 10000)
 
 # Create NGSolve CoefficientFunction for different field types

{radia-1.0.9 → radia-1.0.10}/README_BUILD.md

@@ -349,7 +349,7 @@ import radia as rad
 
 # Create Radia magnet
 magnet = rad.ObjRecMag([0, 0, 0], [20, 20, 30], [0, 0, 1.2])
-rad.MatApl(magnet, rad.MatStd('NdFeB', 1.2))
+rad.MatApl(magnet, rad.MatLin([0.06, 0.17], [0, 0, 1.2]))  # NdFeB
 rad.Solve(magnet, 0.0001, 10000)
 
 # Create field CoefficientFunctions

{radia-1.0.9 → radia-1.0.10}/docs/API_REFERENCE.md

@@ -322,33 +322,64 @@ Creates nonlinear anisotropic material with separate parallel/perpendicular char
 
 ---
 
-### MatStd
+### Common Material Configuration Examples
+
+Below are typical material parameters for common magnetic materials. These can be created using `MatLin` for permanent magnets or `MatSatIsoFrm` for soft magnetic materials.
+
+#### Permanent Magnet Materials (Linear Anisotropic)
+
+**NdFeB** (Neodymium-Iron-Boron):
 ```python
-material = rad.MatStd(name, mr)
+mat = rad.MatLin([0.06, 0.17], [0, 0, 1.2])  # ksi_par=0.06, ksi_perp=0.17, Mr=1.2 T
 ```
-Creates pre-defined magnetic material.
 
-**Parameters**:
-- `name`: Material identifier string
-  - `'NdFeB'`: NdFeB permanent magnet (default mr = 1.2 T)
-  - `'SmCo5'`: SmCo5 permanent magnet (default mr = 0.85 T)
-  - `'Sm2Co17'`: Sm2Co17 permanent magnet (default mr = 1.05 T)
-  - `'Ferrite'`: Ferrite permanent magnet (default mr = 0.35 T)
-  - `'Xc06'`: Low carbon steel C<0.06%
-  - `'Steel37'`: Steel C<0.13%
-  - `'Steel42'`: Steel C<0.19%
-  - `'AFK502'`: Vanadium Permendur (Fe:49%, Co:49%, V:2%)
-  - `'AFK1'`: FeCo alloy (Fe:74.2%, Co:25%)
-- `mr`: Optional remanent magnetization magnitude (T)
+**SmCo5** (Samarium-Cobalt):
+```python
+mat = rad.MatLin([0.005, 0.04], [0, 0, 0.85])  # Mr=0.85 T
+```
 
-**Example**:
+**Sm2Co17** (Samarium-Cobalt 2:17):
+```python
+mat = rad.MatLin([0.005, 0.04], [0, 0, 1.05])  # Mr=1.05 T
+```
+
+**Ferrite**:
+```python
+mat = rad.MatLin([0.07, 0.2], [0, 0, 0.35])  # Mr=0.35 T
+```
+
+#### Soft Magnetic Materials (Nonlinear Isotropic)
+
+**Xc06** (Low Carbon Steel, C<0.06%):
 ```python
-# NdFeB with default 1.2 T remanence
-mat = rad.MatStd('NdFeB')
+mat = rad.MatSatIsoFrm([2118., 1.362], [63.06, 0.2605], [17.138, 0.4917])
+```
+
+**Steel37** (C<0.13%):
+```python
+mat = rad.MatSatIsoFrm([1596.3, 1.1488], [133.11, 0.4268], [18.713, 0.4759])
+```
+
+**Steel42** (C<0.19%):
+```python
+mat = rad.MatSatIsoFrm([968.66, 1.441], [24.65, 0.2912], [8.3, 0.3316])
+```
 
-# Custom remanence
-mat = rad.MatStd('NdFeB', 1.4)
+**AFK502** (Vanadium Permendur, Fe:49%, Co:49%, V:2%):
+```python
+mat = rad.MatSatIsoFrm([10485., 1.788], [241.5, 0.437], [7.43, 0.115])
+```
+
+**AFK1** (FeCo alloy, Fe:74.2%, Co:25%):
+```python
+mat = rad.MatSatIsoFrm([2001., 1.704], [38.56, 0.493], [1.24, 0.152])
+```
+
+**Note**: For soft magnetic materials, the magnetization is modeled as:
+```
+M(H) = ms1*tanh(ksi1*H/ms1) + ms2*tanh(ksi2*H/ms2) + ms3*tanh(ksi3*H/ms3)
 ```
+where H is the magnitude of magnetic field strength in Tesla.
 
 ---
 

{radia-1.0.9 → radia-1.0.10}/examples/NGSolve_Integration/demo_field_types.py

@@ -40,7 +40,7 @@ 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.MatStd('NdFeB', 1.2))
+rad.MatApl(magnet, rad.MatLin([0.06, 0.17], [0, 0, 1.2]))  # NdFeB
 rad.Solve(magnet, 0.0001, 10000)
 
 print(f"Magnet created: object #{magnet}")

{radia-1.0.9 → radia-1.0.10}/examples/NGSolve_Integration/export_radia_geometry.py

@@ -37,7 +37,7 @@ 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.MatStd('NdFeB', 1.2))
+rad.MatApl(magnet, rad.MatLin([0.06, 0.17], [0, 0, 1.2]))  # NdFeB
 rad.Solve(magnet, 0.0001, 10000)
 
 print(f"Magnet created: object #{magnet}")

{radia-1.0.9 → radia-1.0.10}/examples/NGSolve_Integration/visualize_field.py

@@ -52,7 +52,7 @@ 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.MatStd('NdFeB', 1.2))
+rad.MatApl(magnet, rad.MatLin([0.06, 0.17], [0, 0, 1.2]))  # NdFeB
 rad.Solve(magnet, 0.0001, 10000)
 
 print(f"Magnet created: object #{magnet}")

{radia-1.0.9 → radia-1.0.10}/examples/simple_problems/test_update_hmatrix_magnetization.py

@@ -18,9 +18,9 @@ try:
 	print(f"  OK: block={block}, container={g}")
 
 	# Step 2
-	print("\n[Step 2] Setting initial magnetization...")
-	rad.MatApl(g, rad.MatStd('NdFeB', 1000.0))
-	print("  OK: M = [0, 0, 1000] A/m")
+	print("\n[Step 2] Setting material...")
+	rad.MatApl(g, rad.MatLin([0.06, 0.17], [0, 0, 1.2]))  # NdFeB
+	print("  OK: Material applied")
 
 	# Step 3
 	print("\n[Step 3] Enabling H-matrix...")

radia-1.0.10/examples/solver_benchmarks/README.md

@@ -0,0 +1,36 @@
+# Solver Benchmarks
+
+H-matrix field evaluation benchmark.
+
+## Benchmark
+
+### H-matrix Field Evaluation (`benchmark_hmatrix_field.py`)
+
+**Problem:**
+- Grid: 10×10 = 100 rectangular magnets
+- Observation points: 10×10 = 100 points
+- Initial magnetization: [0, 0, 1] T
+
+**Comparison:**
+1. Direct calculation (use_hmatrix=0)
+2. H-matrix calculation (use_hmatrix=1)
+
+**Purpose:**
+Demonstrate H-matrix accuracy and performance for field evaluation.
+
+## Running
+
+```bash
+python benchmark_hmatrix_field.py
+```
+
+## Expected Results
+
+- **Accuracy:** < 1% relative error
+- **Memory:** ~0.2-0.3 MB for N=100
+- **Speedup:** Variable (H-matrix overhead may dominate for small problems)
+
+## References
+
+- CLAUDE.md: H-matrix testing guidelines
+- test_hmatrix_large.py: Original test (same as benchmark_hmatrix_field.py)

radia-1.0.10/examples/solver_benchmarks/benchmark_hmatrix_field.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+"""
+H-matrix accuracy test with 100+ elements and 100+ observation points
+
+This test demonstrates proper H-matrix usage as specified in CLAUDE.md:
+- Use rad.SetHMatrixFieldEval() to enable H-matrix explicitly
+- Use at least 100 elements and 100 observation points
+- Compare H-matrix vs direct calculation accuracy
+"""
+
+import sys
+sys.path.insert(0, r"S:\Radia\01_GitHub\build\Release")
+
+import radia as rad
+import numpy as np
+
+print("=" * 80)
+print("H-Matrix Accuracy Test (100+ elements, 100+ points)")
+print("=" * 80)
+
+# Create geometry: 10x10 grid = 100 rectangular magnets
+rad.UtiDelAll()
+
+magnets = []
+grid_size = 10  # 10x10 = 100 magnets
+
+for i in range(grid_size):
+	for j in range(grid_size):
+		x = i * 15.0  # 15mm spacing
+		y = j * 15.0
+		mag = rad.ObjRecMag([x, y, 0], [10, 10, 10], [0, 0, 1])
+		magnets.append(mag)
+
+container = rad.ObjCnt(magnets)
+
+# Observation points: 10x10 grid = 100 points above the magnets
+obs_points = []
+for i in range(grid_size):
+	for j in range(grid_size):
+		x = i * 15.0 + 7.5  # Center of each cell
+		y = j * 15.0 + 7.5
+		z = 25.0  # 25mm above
+		obs_points.append([x, y, z])
+
+print(f"\n[Setup]")
+print(f"  Number of magnets: {len(magnets)}")
+print(f"  Number of observation points: {len(obs_points)}")
+print(f"  Grid configuration: {grid_size}x{grid_size}")
+
+# Test 1: Direct calculation (use_hmatrix=0)
+print("\n[Test 1] Direct calculation")
+print("-" * 80)
+
+import time
+t0 = time.time()
+H_direct = rad.FldBatch(container, 'h', obs_points, 0)  # use_hmatrix=0
+t_direct = time.time() - t0
+
+H_direct = np.array(H_direct).reshape(-1, 3)
+
+print(f"  Calculation time: {t_direct:.4f} seconds")
+print(f"  First point H: [{H_direct[0,0]:.6e}, {H_direct[0,1]:.6e}, {H_direct[0,2]:.6e}] A/m")
+print(f"  Mean |H|: {np.mean(np.sqrt(np.sum(H_direct**2, axis=1))):.6e} A/m")
+
+# Test 2: H-matrix (use_hmatrix=1)
+print("\n[Test 2] H-matrix calculation")
+print("-" * 80)
+
+# Enable H-matrix explicitly as per CLAUDE.md guidelines
+rad.SetHMatrixFieldEval(1, 1e-6)
+
+t0 = time.time()
+H_hmat = rad.FldBatch(container, 'h', obs_points, 1)  # use_hmatrix=1
+t_hmat = time.time() - t0
+
+H_hmat = np.array(H_hmat).reshape(-1, 3)
+
+print(f"  Calculation time: {t_hmat:.4f} seconds")
+print(f"  First point H: [{H_hmat[0,0]:.6e}, {H_hmat[0,1]:.6e}, {H_hmat[0,2]:.6e}] A/m")
+print(f"  Mean |H|: {np.mean(np.sqrt(np.sum(H_hmat**2, axis=1))):.6e} A/m")
+
+# Compute error
+diff = H_hmat - H_direct
+abs_errors = np.sqrt(np.sum(diff**2, axis=1))
+mag_H = np.sqrt(np.sum(H_direct**2, axis=1))
+rel_errors = abs_errors / (mag_H + 1e-15)  # Avoid division by zero
+
+max_rel_error = np.max(rel_errors)
+mean_rel_error = np.mean(rel_errors)
+
+print(f"\n[Accuracy]")
+print(f"  Max relative error:  {max_rel_error:.6e} ({max_rel_error*100:.4f}%)")
+print(f"  Mean relative error: {mean_rel_error:.6e} ({mean_rel_error*100:.4f}%)")
+print(f"  Max absolute error:  {np.max(abs_errors):.6e} A/m")
+
+print(f"\n[Performance]")
+print(f"  Direct time:  {t_direct:.4f} seconds")
+print(f"  H-matrix time: {t_hmat:.4f} seconds")
+print(f"  Speedup: {t_direct/t_hmat:.2f}x")
+
+# Get H-matrix stats
+stats = rad.GetHMatrixStats()
+print(f"\n[H-matrix Stats]")
+print(f"  Enabled: {stats[0]}")
+print(f"  Cached:  {stats[1]}")
+print(f"  Memory:  {stats[2]:.3f} MB")
+
+# Pass/Fail criteria
+print("\n" + "=" * 80)
+if max_rel_error < 0.01:
+	print(f"PASS: H-matrix accuracy < 1% (actual: {max_rel_error*100:.4f}%)")
+	exit_code = 0
+else:
+	print(f"FAIL: H-matrix accuracy > 1% (actual: {max_rel_error*100:.4f}%)")
+	exit_code = 1
+
+print("=" * 80)
+
+sys.exit(exit_code)

{radia-1.0.9 → radia-1.0.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "radia"
-version = "1.0.9"
+version = "1.0.10"
 description = "Radia 3D Magnetostatics with NGSolve Integration and OpenMP Parallelization"
 readme = "README.md"
 requires-python = ">=3.12"

{radia-1.0.9 → radia-1.0.10}/setup.py

@@ -16,7 +16,7 @@ import shutil
 import sys
 
 # Read version from pyproject.toml
-version = "1.0.9"
+version = "1.0.10"
 
 # Read the README file
 readme_file = Path(__file__).parent / "README.md"

{radia-1.0.9 → radia-1.0.10/src/radia.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: radia
-Version: 1.0.9
+Version: 1.0.10
 Summary: Radia 3D Magnetostatics with NGSolve Integration and OpenMP Parallelization
 Home-page: https://github.com/ksugahar/Radia_NGSolve
 Author: Pascal Elleaume
@@ -150,7 +150,7 @@ import rad_ngsolve
 
 # Create Radia magnet
 magnet = rad.ObjRecMag([0,0,0], [20,20,20], [0,0,1.2])  # mm units
-rad.MatApl(magnet, rad.MatStd('NdFeB', 1.2))
+rad.MatApl(magnet, rad.MatLin([0.06, 0.17], [0,0,1.2]))  # NdFeB
 rad.Solve(magnet, 0.0001, 10000)
 
 # Create NGSolve CoefficientFunction for different field types

{radia-1.0.9 → radia-1.0.10}/src/radia.egg-info/SOURCES.txt

@@ -10,19 +10,14 @@ docs/API_REFERENCE.md
 docs/CF_BACKGROUND_FIELD_IMPLEMENTATION.md
 docs/CLAUDE.md
 docs/DIRECTORY_STRUCTURE.md
-docs/HACAPK_INTEGRATION_COMPLETE.md
-docs/HACAPK_INTEGRATION_PLAN.md
 docs/NGSOLVE_CF_BACKGROUND_FIELD_DESIGN.md
 docs/NGSOLVE_DLL_ISSUE.md
 docs/NGSOLVE_INTEGRATION.md
-docs/NGSOLVE_INTEGRATION_STATUS.md
 docs/NGSOLVE_PYTHON_SOLUTION.md
 docs/NGSOLVE_USAGE_GUIDE.md
 docs/OPENMP_PERFORMANCE_REPORT.md
-docs/PHASE4_STATUS.md
 docs/TAB_CONVERSION_REPORT.md
 docs/hmatrix_field_design.md
-docs/hmatrix_field_progress.md
 docs/scripts/README.md
 examples/test_hmatrix_accuracy.py
 examples/test_hmatrix_cube_nonlinear.py
@@ -89,6 +84,8 @@ examples/smco_magnet_array/smbo.pvsm
 examples/smco_magnet_array/smco_array.py
 examples/smco_magnet_array/smco_array.vtk
 examples/smco_magnet_array/smco_field_distribution.vtk
+examples/solver_benchmarks/README.md
+examples/solver_benchmarks/benchmark_hmatrix_field.py
 examples/solver_time_evaluation/README.md
 examples/solver_time_evaluation/benchmark_linear_material.py
 examples/solver_time_evaluation/benchmark_lu_vs_gs.py
@@ -113,13 +110,18 @@ tests/__init__.py
 tests/benchmark_hmatrix.py
 tests/conftest.py
 tests/test_advanced.py
+tests/test_group_operations.py
 tests/test_magpylib_comparison.py
+tests/test_materials.py
 tests/test_parallel_performance.py
 tests/test_rad_ngsolve.py
 tests/test_radhmat.py
 tests/test_radia.py
+tests/test_serialization.py
 tests/test_simple.py
 tests/test_square_coil_analytical.py
+tests/test_transformations.py
+tests/test_type_cast.py
 tests/test_utils.py
 tests/test_vector_potential.py
 tests/benchmarks/benchmark_correct.py

{radia-1.0.9 → radia-1.0.10}/tests/test_advanced.py

@@ -150,8 +150,8 @@ def test_iron_core():
 	core = rad.ObjRecMag([0, 0, 0], [40, 40, 100])
 	print(f"   Core created: ID={core}")
 
-	# Create iron material
-	mat_iron = rad.MatStd('Steel37', 2000)
+	# Create iron material (Steel37 equivalent)
+	mat_iron = rad.MatSatIsoFrm([1596.3, 1.1488], [133.11, 0.4268], [18.713, 0.4759])
 	rad.MatApl(core, mat_iron)
 	print(f"   Iron material applied")
 

radia-1.0.10/tests/test_group_operations.py

@@ -0,0 +1,238 @@
+"""
+Unit tests for radgroup.cpp - Object grouping operations
+
+Tests ObjCnt (Container/Group) functionality:
+- Group creation
+- Adding/removing objects
+- Group transformations
+- Nested groups
+"""
+
+import sys
+sys.path.insert(0, r"S:\Radia\01_GitHub\build\Release")
+
+import pytest
+import radia as rad
+import numpy as np
+
+
+class TestGroupCreation:
+	"""Test basic group creation and structure"""
+
+	def test_empty_group(self):
+		"""Test creating an empty group"""
+		rad.UtiDelAll()
+		group = rad.ObjCnt([])
+		assert group > 0, "Empty group should have valid index"
+
+	def test_single_object_group(self):
+		"""Test group with single object"""
+		rad.UtiDelAll()
+		mag = rad.ObjRecMag([0, 0, 0], [10, 10, 10], [0, 0, 1])
+		group = rad.ObjCnt([mag])
+		assert group > 0
+
+	def test_multiple_objects_group(self):
+		"""Test group with multiple objects"""
+		rad.UtiDelAll()
+
+		mags = []
+		for i in range(5):
+			mag = rad.ObjRecMag([i*20, 0, 0], [10, 10, 10], [0, 0, 1])
+			mags.append(mag)
+
+		group = rad.ObjCnt(mags)
+		assert group > 0
+
+		# Test field evaluation on group
+		H = rad.Fld(group, 'h', [50, 0, 0])
+		assert len(H) == 3, "Should return 3D field vector"
+
+	def test_nested_groups(self):
+		"""Test creating nested groups"""
+		rad.UtiDelAll()
+
+		# Create two sub-groups
+		group1_mags = [
+			rad.ObjRecMag([0, 0, 0], [10, 10, 10], [0, 0, 1]),
+			rad.ObjRecMag([20, 0, 0], [10, 10, 10], [0, 0, 1])
+		]
+		group1 = rad.ObjCnt(group1_mags)
+
+		group2_mags = [
+			rad.ObjRecMag([0, 20, 0], [10, 10, 10], [0, 0, 1]),
+			rad.ObjRecMag([20, 20, 0], [10, 10, 10], [0, 0, 1])
+		]
+		group2 = rad.ObjCnt(group2_mags)
+
+		# Create parent group
+		parent_group = rad.ObjCnt([group1, group2])
+		assert parent_group > 0
+
+		# Test field from nested group
+		H = rad.Fld(parent_group, 'h', [10, 10, 0])
+		assert len(H) == 3
+
+
+class TestGroupTransformations:
+	"""Test transformations applied to groups"""
+
+	def test_translate_group(self):
+		"""Test translating entire group"""
+		rad.UtiDelAll()
+
+		# Create group at origin
+		mags = []
+		for i in range(3):
+			mag = rad.ObjRecMag([i*10, 0, 0], [5, 5, 5], [0, 0, 1])
+			mags.append(mag)
+		group = rad.ObjCnt(mags)
+
+		# Field at origin before translation
+		H_before = rad.Fld(group, 'h', [0, 0, 20])
+
+		# Translate group
+		rad.TrfOrnt(group, rad.TrfTrsl([0, 100, 0]))
+
+		# Field at translated position
+		H_after = rad.Fld(group, 'h', [0, 100, 20])
+
+		# Fields should be similar (geometry moved)
+		assert np.allclose(H_before, H_after, rtol=1e-6)
+
+	def test_rotate_group(self):
+		"""Test rotating entire group"""
+		rad.UtiDelAll()
+
+		# Create asymmetric group
+		mag1 = rad.ObjRecMag([10, 0, 0], [5, 5, 5], [1, 0, 0])
+		mag2 = rad.ObjRecMag([20, 0, 0], [5, 5, 5], [1, 0, 0])
+		group = rad.ObjCnt([mag1, mag2])
+
+		# Rotate 90 degrees around z-axis
+		rad.TrfOrnt(group, rad.TrfRot([0, 0, 0], [0, 0, 1], np.pi/2))
+
+		# After rotation, magnets should be along y-axis
+		# Field at rotated position should make sense
+		H = rad.Fld(group, 'h', [0, 15, 0])
+		assert len(H) == 3
+
+	def test_multiple_transformations(self):
+		"""Test combining multiple transformations"""
+		rad.UtiDelAll()
+
+		mag = rad.ObjRecMag([0, 0, 0], [10, 10, 10], [0, 0, 1])
+		group = rad.ObjCnt([mag])
+
+		# Translate
+		rad.TrfOrnt(group, rad.TrfTrsl([10, 0, 0]))
+
+		# Rotate
+		rad.TrfOrnt(group, rad.TrfRot([0, 0, 0], [0, 0, 1], np.pi/4))
+
+		# Should still compute field
+		H = rad.Fld(group, 'h', [20, 0, 0])
+		assert len(H) == 3
+
+
+class TestGroupMaterialApplication:
+	"""Test applying materials to groups"""
+
+	def test_material_to_group(self):
+		"""Test applying material to entire group"""
+		rad.UtiDelAll()
+
+		# Create group without material
+		mags = []
+		for i in range(3):
+			mag = rad.ObjRecMag([i*15, 0, 0], [10, 10, 10], [0, 0, 1])
+			mags.append(mag)
+		group = rad.ObjCnt(mags)
+
+		# Apply material to group
+		mat = rad.MatLin([1000, 0], [10, 10, 10])
+		rad.MatApl(group, mat)
+
+		# Field should be computed
+		H = rad.Fld(group, 'h', [20, 0, 0])
+		assert len(H) == 3
+		assert not np.allclose(H, [0, 0, 0])  # Should have non-zero field
+
+
+class TestGroupFieldEvaluation:
+	"""Test field evaluation from groups"""
+
+	def test_field_from_group_vs_individual(self):
+		"""Compare field from group vs sum of individual objects"""
+		rad.UtiDelAll()
+
+		# Create individual magnets
+		mag1 = rad.ObjRecMag([0, 0, 0], [10, 10, 10], [0, 0, 1])
+		rad.MatApl(mag1, rad.MatLin([1000, 0], [10, 10, 10]))
+
+		mag2 = rad.ObjRecMag([20, 0, 0], [10, 10, 10], [0, 0, 1])
+		rad.MatApl(mag2, rad.MatLin([1000, 0], [10, 10, 10]))
+
+		# Field from individual objects
+		H1 = np.array(rad.Fld(mag1, 'h', [30, 0, 0]))
+		H2 = np.array(rad.Fld(mag2, 'h', [30, 0, 0]))
+		H_sum = H1 + H2
+
+		# Field from group
+		group = rad.ObjCnt([mag1, mag2])
+		H_group = np.array(rad.Fld(group, 'h', [30, 0, 0]))
+
+		# Should be equal (superposition principle)
+		assert np.allclose(H_sum, H_group, rtol=1e-10)
+
+	def test_batch_field_from_group(self):
+		"""Test FldBatch with groups"""
+		rad.UtiDelAll()
+
+		mags = []
+		for i in range(5):
+			mag = rad.ObjRecMag([i*15, 0, 0], [10, 10, 10], [0, 0, 1])
+			rad.MatApl(mag, rad.MatLin([1000, 0], [10, 10, 10]))
+			mags.append(mag)
+
+		group = rad.ObjCnt(mags)
+
+		# Evaluate at multiple points
+		points = [[x, 0, 0] for x in [10, 20, 30, 40]]
+		H_batch = rad.FldBatch(group, 'h', points, 0)  # Direct calculation
+
+		assert len(H_batch) == 4, "Should return 4 field vectors"
+		for H in H_batch:
+			assert len(H) == 3, "Each field should be 3D"
+
+
+class TestGroupEdgeCases:
+	"""Test edge cases and error handling"""
+
+	def test_group_with_duplicate_objects(self):
+		"""Test group containing same object multiple times"""
+		rad.UtiDelAll()
+
+		mag = rad.ObjRecMag([0, 0, 0], [10, 10, 10], [0, 0, 1])
+
+		# Create group with duplicates (should handle gracefully)
+		group = rad.ObjCnt([mag, mag, mag])
+		assert group > 0
+
+	def test_deeply_nested_groups(self):
+		"""Test deeply nested group hierarchy"""
+		rad.UtiDelAll()
+
+		# Create deep nesting: group -> group -> group -> magnet
+		mag = rad.ObjRecMag([0, 0, 0], [10, 10, 10], [0, 0, 1])
+		level1 = rad.ObjCnt([mag])
+		level2 = rad.ObjCnt([level1])
+		level3 = rad.ObjCnt([level2])
+
+		# Should still compute field
+		H = rad.Fld(level3, 'h', [20, 0, 0])
+		assert len(H) == 3
+
+
+if __name__ == "__main__":
+	pytest.main([__file__, "-v"])

{radia-1.0.9 → radia-1.0.10}/tests/test_magpylib_comparison.py

@@ -228,13 +228,14 @@ def test_cylindrical_magnet_comparison():
 		print(f"[PASS] Radia and magpylib agree within {tolerance_percent}% tolerance")
 		print(f"       Difference: {diff_percent:.2f}%")
 		print("=" * 70)
-		return True
 	else:
 		print(f"[FAIL] Radia and magpylib differ by {diff_percent:.2f}%")
 		print(f"       Exceeds {tolerance_percent}% tolerance")
 		print(f"       Check magnetization unit conversion!")
 		print("=" * 70)
-		return False
+
+	# Use assertion for pytest
+	assert passed, f"Radia and magpylib differ by {diff_percent:.2f}%, exceeds {tolerance_percent}% tolerance"
 
 def main():
 	"""Run the comparison test"""