radia 1.1.1__tar.gz → 1.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: radia
-Version: 1.1.1
+Version: 1.2.0
 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/docs/README.md

@@ -0,0 +1,63 @@
+# Radia Documentation
+
+This folder contains the official documentation for Radia.
+
+## Documentation Organization
+
+### User Documentation (Essential Reading)
+
+#### API Documentation
+- [API_REFERENCE.md](API_REFERENCE.md) - Complete Python API reference
+- [API_EXTENSIONS.md](API_EXTENSIONS.md) - Extended features and new APIs
+
+#### H-Matrix Acceleration
+- [HMATRIX_USER_GUIDE.md](HMATRIX_USER_GUIDE.md) - User guide for H-matrix acceleration
+- [HMATRIX_BENCHMARKS_RESULTS.md](HMATRIX_BENCHMARKS_RESULTS.md) - Performance benchmarks
+- [HMATRIX_SERIALIZATION.md](HMATRIX_SERIALIZATION.md) - Disk cache feature
+
+#### NGSolve Integration
+- [NGSOLVE_USAGE_GUIDE.md](NGSOLVE_USAGE_GUIDE.md) - How to use Radia with NGSolve
+- [NGSOLVE_INTEGRATION.md](NGSOLVE_INTEGRATION.md) - Integration overview
+
+### Developer Documentation (Implementation Details)
+
+#### H-Matrix Implementation
+- [HMATRIX_IMPLEMENTATION_HISTORY.md](HMATRIX_IMPLEMENTATION_HISTORY.md) - Development history
+- [HMATRIX_ENHANCEMENT_PROPOSAL_2025.md](HMATRIX_ENHANCEMENT_PROPOSAL_2025.md) - Future enhancements
+- [hmatrix_field_design.md](hmatrix_field_design.md) - Field evaluation design
+- [ML_PARAMETER_TUNING.md](ML_PARAMETER_TUNING.md) - Machine learning parameter optimization
+
+#### Material and Field APIs
+- [MATERIAL_API_IMPLEMENTATION.md](MATERIAL_API_IMPLEMENTATION.md) - Material property implementation
+- [CF_BACKGROUND_FIELD_IMPLEMENTATION.md](CF_BACKGROUND_FIELD_IMPLEMENTATION.md) - Background field implementation
+- [NGSOLVE_CF_BACKGROUND_FIELD_DESIGN.md](NGSOLVE_CF_BACKGROUND_FIELD_DESIGN.md) - NGSolve CoefficientFunction design
+
+## Additional Resources
+
+### Development Notes
+Implementation notes, performance analysis, and troubleshooting are in [../dev/notes/](../dev/notes/):
+- Implementation details (directory structure, conversion reports)
+- Performance analysis (OpenMP, H-matrix optimizations)
+- Issue resolutions (DLL issues, integration problems)
+
+### Release History
+Release notes and version history are in [../dev/notes/releases/](../dev/notes/releases/).
+
+### Examples
+Working code examples are in [../examples/](../examples/):
+- [simple_problems/](../examples/simple_problems/) - Basic examples
+- [solver_benchmarks/](../examples/solver_benchmarks/) - Performance benchmarks
+- [ngsolve_integration/](../examples/ngsolve_integration/) - NGSolve integration examples
+
+## Quick Start
+
+1. **New users**: Start with [API_REFERENCE.md](API_REFERENCE.md) and [examples/simple_problems/](../examples/simple_problems/)
+2. **Performance optimization**: Read [HMATRIX_USER_GUIDE.md](HMATRIX_USER_GUIDE.md)
+3. **NGSolve users**: Read [NGSOLVE_USAGE_GUIDE.md](NGSOLVE_USAGE_GUIDE.md)
+4. **Contributors**: Review [HMATRIX_IMPLEMENTATION_HISTORY.md](HMATRIX_IMPLEMENTATION_HISTORY.md)
+
+## See Also
+
+- [Main README](../README.md) - Project overview and installation
+- [Build Instructions](../README_BUILD.md) - How to build from source
+- [CHANGELOG](../CHANGELOG.md) - Version history

radia-1.2.0/examples/simple_problems/README.md

@@ -0,0 +1,134 @@
+# Radia Simple Examples
+
+This folder contains basic Radia examples demonstrating fundamental features.
+
+## Example Files
+
+- [arc_current_with_magnet.py](arc_current_with_magnet.py) - Arc current with rectangular magnet
+- [arc_current_dual_magnets.py](arc_current_dual_magnets.py) - Arc current with two magnets
+- [chamfered_pole_piece.py](chamfered_pole_piece.py) - Multiple extrusion with chamfer
+- [cubic_polyhedron_magnet.py](cubic_polyhedron_magnet.py) - Polyhedron (cube) magnet
+- [compare_magpylib.py](compare_magpylib.py) - Comparison with magpylib library
+- [hmatrix_update_magnetization.py](hmatrix_update_magnetization.py) - H-matrix magnetization update
+
+## How to Run
+
+Each Python file can be run independently:
+
+```bash
+cd examples/simple_problems
+python arc_current_with_magnet.py
+python arc_current_dual_magnets.py
+python chamfered_pole_piece.py
+python cubic_polyhedron_magnet.py
+```
+
+## Example Descriptions
+
+### arc_current_with_magnet.py
+- Creates arc current element and rectangular magnet
+- Applies linear material properties
+- Calculates magnetic field at origin
+
+**Key Functions:**
+- `rad.ObjArcCur()` - Create arc current element
+- `rad.ObjRecMag()` - Create rectangular magnet
+- `rad.MatLin([ksi_par, ksi_perp], [mx,my,mz])` - Define anisotropic linear material
+- `rad.MatApl(obj, mat)` - Apply material to object
+- `rad.Fld(obj, 'b', [x,y,z])` - Calculate magnetic field
+
+### arc_current_dual_magnets.py
+- Arc current with two magnets at different positions
+- Manages multiple objects with container
+- Applies linear material properties
+
+**Key Functions:**
+- `rad.ObjCnt([obj1, obj2, ...])` - Create object container
+
+### chamfered_pole_piece.py
+- Complex extrusion shape with chamfer
+- Defines multiple cross-sections and extrudes
+- Element subdivision
+
+**Key Functions:**
+- `rad.ObjMltExtRtg()` - Create multiple extrusion rectangle
+- `rad.ObjDivMag()` - Subdivide magnet
+
+### cubic_polyhedron_magnet.py
+- Creates polyhedron from vertices and faces
+- Cube example
+
+**Key Functions:**
+- `rad.ObjPolyhdr()` - Create polyhedron
+
+## Radia Python API Basics
+
+1. **Import module**
+   ```python
+   import radia as rad
+   ```
+
+2. **Create objects**
+   ```python
+   # Rectangular magnet: position, dimensions, magnetization
+   mag = rad.ObjRecMag([0,0,0], [10,10,10], [0,0,1.0])
+
+   # Arc current: center, [rmin,rmax], [phimin,phimax], height, segments, current
+   arc = rad.ObjArcCur([0,0,0], [100,150], [0, 6.28], 20, 20, 10)
+   ```
+
+3. **Material properties**
+   ```python
+   # Anisotropic linear material: [ksi_parallel, ksi_perpendicular], magnetization vector
+   mat = rad.MatLin([0.06, 0.17], [0,0,1])
+   rad.MatApl(obj, mat)
+   ```
+
+4. **Field calculation**
+   ```python
+   # Magnetic flux density [T]
+   B = rad.Fld(obj, 'b', [x, y, z])
+
+   # Magnetic field strength [A/m]
+   H = rad.Fld(obj, 'h', [x, y, z])
+   ```
+
+5. **3D Visualization**
+   ```python
+   # Export to VTK for ParaView visualization
+   from radia_vtk_export import exportGeometryToVTK
+   exportGeometryToVTK(obj, 'output.vtk')
+   ```
+
+## Requirements
+
+- Python 3.12+
+- Radia module (installed via pip or built from source)
+- NumPy
+
+## Troubleshooting
+
+### ModuleNotFoundError: No module named 'radia'
+
+Install Radia:
+```bash
+pip install radia
+```
+
+Or build from source and install locally:
+```bash
+cd ../..
+python -m pip install .
+```
+
+### Field calculation returns zero
+
+- Check that magnetization is set on the object
+- Verify material properties are correctly applied
+- Ensure object ID is valid
+
+## See Also
+
+- [Radia Official Documentation](https://www.esrf.fr/Accelerators/Groups/InsertionDevices/Software/Radia)
+- [API Reference](../../docs/API_REFERENCE.md)
+- [H-Matrix User Guide](../../docs/HMATRIX_USER_GUIDE.md)

{radia-1.1.1 → radia-1.2.0}/examples/solver_benchmarks/benchmark_hmatrix_field.py

@@ -9,7 +9,8 @@ This test demonstrates proper H-matrix usage as specified in CLAUDE.md:
 """
 
 import sys
-sys.path.insert(0, r"S:\Radia\01_GitHub\build\Release")
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../build/Release'))
 
 import radia as rad
 import numpy as np

{radia-1.1.1 → radia-1.2.0}/examples/solver_benchmarks/benchmark_linear_material.py

@@ -5,9 +5,10 @@ Linear materials converge in 0-1 iterations, so only matrix construction is rele
 """
 
 import sys
+import os
 import numpy as np
 from time import perf_counter
-sys.path.insert(0, r"S:\Radia\01_GitHub\build\Release")
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../build/Release'))
 
 import radia as rad
 

{radia-1.1.1 → radia-1.2.0}/examples/solver_benchmarks/benchmark_matrix_construction.py

@@ -5,9 +5,10 @@ Verify O(N^2) scaling
 """
 
 import sys
+import os
 import numpy as np
 from time import perf_counter
-sys.path.insert(0, r"S:\Radia\01_GitHub\build\Release")
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../build/Release'))
 
 import radia as rad
 

radia-1.2.0/examples/solver_benchmarks/benchmark_solver_methods.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python
+"""
+Solver Methods Benchmark: Direct vs Relaxation vs Relaxation+H-matrix
+
+Compares three solver methods for magnetic field problems:
+1. Direct calculation (no solver, uses initial magnetization)
+2. Standard relaxation solver
+3. H-matrix accelerated relaxation solver
+
+Problem: Nonlinear magnetic material with applied background field
+
+Performance metrics:
+- Computation time
+- Field accuracy (comparing all methods)
+"""
+
+import sys
+import os
+import time
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../build/Release'))
+
+import radia as rad
+import numpy as np
+
+print("=" * 80)
+print("Solver Methods Benchmark")
+print("Direct / Relaxation / Relaxation+H-matrix Comparison")
+print("=" * 80)
+
+# Test configurations
+test_cases = [
+	{"n": 3, "desc": "Small (N=27)"},
+	{"n": 5, "desc": "Medium (N=125)"},
+	{"n": 7, "desc": "Large (N=343)"},
+]
+
+# Solver parameters
+precision = 0.0001
+max_iter = 1000
+
+# Background field (uniform field applied to material)
+# Note: In Radia, ObjBckg() uses Tesla, and field values are in Radia's internal units
+# where H and B are numerically equal. Use value ~1.0 for moderate field.
+H_bg = [1.0, 0, 0]  # 1.0 T background field in X direction
+
+# Observation point
+obs_point = [0, 0, 50]  # 50mm above center
+
+print("\nProblem Setup:")
+print("  Material: Nonlinear (Steel37)")
+print("  Background field: [{}, {}, {}] T".format(*H_bg))
+print("  Observation point: [{}, {}, {}] mm".format(*obs_point))
+print("  Solver precision: {}".format(precision))
+print("  Max iterations: {}".format(max_iter))
+
+results = []
+
+for test in test_cases:
+	n = test["n"]
+	desc = test["desc"]
+
+	print("\n" + "=" * 80)
+	print("Test Case: {}".format(desc))
+	print("=" * 80)
+
+	size = 20.0  # mm (total cube size)
+	elem_size = size / n
+
+	# ========================================
+	# Method 1: Direct Calculation
+	# ========================================
+	print("\n[Method 1] Direct Calculation (no solver)")
+	print("-" * 80)
+	rad.UtiDelAll()
+
+	# Create material
+	mat = rad.MatSatIsoFrm([1596.3, 1.1488], [133.11, 0.4268], [18.713, 0.4759])
+
+	# Create geometry with initial magnetization
+	elements = []
+	for i in range(n):
+		for j in range(n):
+			for k in range(n):
+				x = -size/2 + (i + 0.5) * elem_size
+				y = -size/2 + (j + 0.5) * elem_size
+				z = -size/2 + (k + 0.5) * elem_size
+				# No initial magnetization (material will respond to background field)
+				elem = rad.ObjRecMag([x, y, z], [elem_size, elem_size, elem_size])
+				rad.MatApl(elem, mat)
+				elements.append(elem)
+
+	# Add background field source to container
+	bg_field = rad.ObjBckg(H_bg)
+	container = rad.ObjCnt(elements + [bg_field])
+
+	print("  Elements: {} ({}×{}×{})".format(len(elements), n, n, n))
+
+	# Direct field calculation (using initial magnetization only)
+	t0 = time.perf_counter()
+	H_direct = rad.Fld(container, 'h', obs_point)
+	t_direct = time.perf_counter() - t0
+
+	print("  Time: {:.6f} s".format(t_direct))
+	print("  H: [{:.6e}, {:.6e}, {:.6e}] A/m".format(*H_direct))
+	H_mag_direct = np.linalg.norm(H_direct)
+	print("  |H|: {:.6e} A/m".format(H_mag_direct))
+
+	# ========================================
+	# Method 2: Standard Relaxation
+	# ========================================
+	print("\n[Method 2] Standard Relaxation (no H-matrix)")
+	print("-" * 80)
+	rad.UtiDelAll()
+
+	# Recreate geometry
+	mat = rad.MatSatIsoFrm([1596.3, 1.1488], [133.11, 0.4268], [18.713, 0.4759])
+
+	elements = []
+	for i in range(n):
+		for j in range(n):
+			for k in range(n):
+				x = -size/2 + (i + 0.5) * elem_size
+				y = -size/2 + (j + 0.5) * elem_size
+				z = -size/2 + (k + 0.5) * elem_size
+				# No initial magnetization - pure soft magnetic material
+				elem = rad.ObjRecMag([x, y, z], [elem_size, elem_size, elem_size])
+				rad.MatApl(elem, mat)
+				elements.append(elem)
+
+	# Add background field source to container
+	bg_field = rad.ObjBckg(H_bg)
+	container = rad.ObjCnt(elements + [bg_field])
+
+	# Disable H-matrix for standard relaxation
+	rad.SolverHMatrixDisable()
+
+	# Run relaxation solver
+	t0 = time.perf_counter()
+	result_relax = rad.Solve(container, precision, max_iter)
+	t_relax = time.perf_counter() - t0
+
+	H_relax = rad.Fld(container, 'h', obs_point)
+
+	print("  Time: {:.6f} s".format(t_relax))
+	print("  H: [{:.6e}, {:.6e}, {:.6e}] A/m".format(*H_relax))
+	H_mag_relax = np.linalg.norm(H_relax)
+	print("  |H|: {:.6e} A/m".format(H_mag_relax))
+	print("  Convergence: {}".format(result_relax))
+
+	# ========================================
+	# Method 3: H-matrix Relaxation
+	# ========================================
+	print("\n[Method 3] H-matrix Accelerated Relaxation")
+	print("-" * 80)
+	rad.UtiDelAll()
+
+	# Recreate geometry
+	mat = rad.MatSatIsoFrm([1596.3, 1.1488], [133.11, 0.4268], [18.713, 0.4759])
+
+	elements = []
+	for i in range(n):
+		for j in range(n):
+			for k in range(n):
+				x = -size/2 + (i + 0.5) * elem_size
+				y = -size/2 + (j + 0.5) * elem_size
+				z = -size/2 + (k + 0.5) * elem_size
+				# No initial magnetization - pure soft magnetic material
+				elem = rad.ObjRecMag([x, y, z], [elem_size, elem_size, elem_size])
+				rad.MatApl(elem, mat)
+				elements.append(elem)
+
+	# Add background field source to container
+	bg_field = rad.ObjBckg(H_bg)
+	container = rad.ObjCnt(elements + [bg_field])
+
+	# Enable H-matrix for relaxation
+	rad.SolverHMatrixEnable()
+
+	# Run relaxation solver with H-matrix
+	t0 = time.perf_counter()
+	result_hmat = rad.Solve(container, precision, max_iter)
+	t_hmat = time.perf_counter() - t0
+
+	H_hmat = rad.Fld(container, 'h', obs_point)
+
+	# Get H-matrix stats
+	stats = rad.GetHMatrixStats()
+
+	print("  Time: {:.6f} s".format(t_hmat))
+	print("  H: [{:.6e}, {:.6e}, {:.6e}] A/m".format(*H_hmat))
+	H_mag_hmat = np.linalg.norm(H_hmat)
+	print("  |H|: {:.6e} A/m".format(H_mag_hmat))
+	print("  Convergence: {}".format(result_hmat))
+	print("  H-matrix memory: {:.3f} MB".format(stats[2]))
+
+	# ========================================
+	# Comparison
+	# ========================================
+	print("\n[Comparison]")
+	print("-" * 80)
+
+	# Use standard relaxation as reference
+	H_ref = np.array(H_relax)
+	H_ref_mag = np.linalg.norm(H_ref)
+
+	# Direct vs Relaxation error
+	diff_direct = np.array(H_direct) - H_ref
+	err_direct = np.linalg.norm(diff_direct) / (H_ref_mag + 1e-15) * 100
+
+	# H-matrix vs Relaxation error
+	diff_hmat = np.array(H_hmat) - H_ref
+	err_hmat = np.linalg.norm(diff_hmat) / (H_ref_mag + 1e-15) * 100
+
+	print("  Reference: Standard Relaxation |H| = {:.6e} A/m".format(H_ref_mag))
+	print("")
+	print("  Method           Time (s)    |H| (A/m)        Error (%)   Speedup")
+	print("  " + "-" * 72)
+	print("  Direct         {:9.6f}  {:14.6e}  {:11.4f}        -".format(
+		t_direct, H_mag_direct, err_direct))
+	print("  Relaxation     {:9.6f}  {:14.6e}  {:11.4f}     1.00x".format(
+		t_relax, H_mag_relax, 0.0))
+	print("  H-matrix       {:9.6f}  {:14.6e}  {:11.4f}  {:7.2f}x".format(
+		t_hmat, H_mag_hmat, err_hmat, t_relax/t_hmat if t_hmat > 0 else 0))
+
+	results.append({
+		"n": n,
+		"n_elem": n**3,
+		"t_direct": t_direct,
+		"t_relax": t_relax,
+		"t_hmat": t_hmat,
+		"err_direct": err_direct,
+		"err_hmat": err_hmat,
+		"speedup": t_relax/t_hmat if t_hmat > 0 else 0
+	})
+
+# ========================================
+# Summary
+# ========================================
+print("\n" + "=" * 80)
+print("SUMMARY")
+print("=" * 80)
+print("\n{:>6s} {:>8s}  {:>12s} {:>12s} {:>12s}  {:>10s} {:>10s}  {:>10s}".format(
+	"N", "Elements",
+	"Direct (s)", "Relax (s)", "H-mat (s)",
+	"Dir Err(%)", "H-mat Err(%)",
+	"Speedup"))
+print("-" * 80)
+
+for r in results:
+	print("{:>6d} {:>8d}  {:>12.6f} {:>12.6f} {:>12.6f}  {:>10.4f} {:>10.4f}  {:>10.2f}x".format(
+		r["n"], r["n_elem"],
+		r["t_direct"], r["t_relax"], r["t_hmat"],
+		r["err_direct"], r["err_hmat"],
+		r["speedup"]))
+
+print("=" * 80)
+print("\nNotes:")
+print("  - Direct: Uses initial magnetization only (no iterations)")
+print("  - Relaxation: Standard solver (reference for accuracy)")
+print("  - H-matrix: Accelerated solver (best for large problems N > 100)")
+print("  - Error: Relative difference from Relaxation method")
+print("=" * 80)
+
+rad.UtiDelAll()

{radia-1.1.1 → radia-1.2.0}/pyproject.toml

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

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

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

{radia-1.1.1 → radia-1.2.0}/src/radia.egg-info/SOURCES.txt

@@ -8,31 +8,20 @@ setup.py
 docs/API_EXTENSIONS.md
 docs/API_REFERENCE.md
 docs/CF_BACKGROUND_FIELD_IMPLEMENTATION.md
-docs/DIRECTORY_STRUCTURE.md
-docs/EXAMPLES_REVIEW.md
 docs/HMATRIX_BENCHMARKS_RESULTS.md
 docs/HMATRIX_ENHANCEMENT_PROPOSAL_2025.md
 docs/HMATRIX_IMPLEMENTATION_HISTORY.md
-docs/HMATRIX_MATVEC_OPTIMIZATION.md
-docs/HMATRIX_PERFORMANCE_IMPROVEMENT.md
 docs/HMATRIX_SERIALIZATION.md
 docs/HMATRIX_USER_GUIDE.md
 docs/MATERIAL_API_IMPLEMENTATION.md
 docs/ML_PARAMETER_TUNING.md
 docs/NGSOLVE_CF_BACKGROUND_FIELD_DESIGN.md
-docs/NGSOLVE_DLL_ISSUE.md
 docs/NGSOLVE_INTEGRATION.md
-docs/NGSOLVE_PYTHON_SOLUTION.md
 docs/NGSOLVE_USAGE_GUIDE.md
-docs/OPENMP_PERFORMANCE_REPORT.md
-docs/PHASE3_PERFORMANCE_ISSUE.md
-docs/PYPI_RELEASE_v1.0.10.md
-docs/RELEASE_NOTES_v1.0.10.md
-docs/TAB_CONVERSION_REPORT.md
+docs/README.md
 docs/hmatrix_field_design.md
 docs/scripts/README.md
 examples/README.md
-examples/H-matrix/benchmark_solver.py
 examples/NGSolve_Integration/HMATRIX_ANALYSIS.md
 examples/NGSolve_Integration/HMATRIX_FIELD_EVALUATION_ISSUE.md
 examples/NGSolve_Integration/H_MATRIX_PARALLEL_OPTIMIZATION.md
@@ -43,7 +32,6 @@ examples/NGSolve_Integration/README.md
 examples/NGSolve_Integration/SET_VS_INTERPOLATE_SIMPLE.md
 examples/NGSolve_Integration/SOLVER_OPTIMIZATION_PROPOSAL.md
 examples/NGSolve_Integration/benchmark_gridfunction_set.py
-examples/NGSolve_Integration/debug_field_values.py
 examples/NGSolve_Integration/demo_field_types.py
 examples/NGSolve_Integration/export_radia_geometry.py
 examples/NGSolve_Integration/radia_field.pvsm
@@ -76,6 +64,26 @@ examples/electromagnet/field_distribution.vtk
 examples/electromagnet/magnet.py
 examples/electromagnet/racetrack_coil_model.py
 examples/electromagnet/yoke_model.py
+examples/ngsolve_integration/HMATRIX_ANALYSIS.md
+examples/ngsolve_integration/HMATRIX_FIELD_EVALUATION_ISSUE.md
+examples/ngsolve_integration/H_MATRIX_PARALLEL_OPTIMIZATION.md
+examples/ngsolve_integration/NGBEM_ANALYSIS.md
+examples/ngsolve_integration/NGSOLVE_SET_VS_INTERPOLATE.md
+examples/ngsolve_integration/PROPOSAL_VECTORIZED_API.md
+examples/ngsolve_integration/README.md
+examples/ngsolve_integration/SET_VS_INTERPOLATE_SIMPLE.md
+examples/ngsolve_integration/SOLVER_OPTIMIZATION_PROPOSAL.md
+examples/ngsolve_integration/benchmark_gridfunction_set.py
+examples/ngsolve_integration/demo_field_types.py
+examples/ngsolve_integration/export_radia_geometry.py
+examples/ngsolve_integration/radia_field.pvsm
+examples/ngsolve_integration/test_batch_evaluation.py
+examples/ngsolve_integration/test_batch_fld.py
+examples/ngsolve_integration/test_coordinate_transform.py
+examples/ngsolve_integration/test_mesh_convergence.py
+examples/ngsolve_integration/test_set_vs_interpolate.py
+examples/ngsolve_integration/verify_curl_A_equals_B.py
+examples/ngsolve_integration/visualize_field.py
 examples/simple_problems/CONVERSION_NOTES.md
 examples/simple_problems/README.md
 examples/simple_problems/arc_current_dual_magnets.py
@@ -104,6 +112,7 @@ examples/solver_benchmarks/benchmark_matrix_construction.py
 examples/solver_benchmarks/benchmark_parallel_construction.py
 examples/solver_benchmarks/benchmark_solver.py
 examples/solver_benchmarks/benchmark_solver_comparison.py
+examples/solver_benchmarks/benchmark_solver_methods.py
 examples/solver_benchmarks/benchmark_solver_scaling.py
 examples/solver_benchmarks/benchmark_solver_scaling_extended.py
 examples/solver_benchmarks/plot_benchmark_results.py
@@ -130,6 +139,7 @@ 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_new_material_api.py
 tests/test_objbckg_simple.py
@@ -143,6 +153,7 @@ tests/test_simple.py
 tests/test_square_coil_analytical.py
 tests/test_transformations.py
 tests/test_type_cast.py
+tests/test_update_hmatrix_magnetization.py
 tests/test_utils.py
 tests/test_vector_potential.py
 tests/benchmarks/benchmark_correct.py