radia 1.3.5__py3-none-any.whl → 1.3.7__py3-none-any.whl

python/__init__.py

@@ -0,0 +1,2 @@
+# Radia Python package
+__version__ = "1.1.0"

{radia-1.3.5.dist-info → radia-1.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: radia
-Version: 1.3.5
+Version: 1.3.7
 Summary: Radia 3D Magnetostatics with NGSolve Integration and OpenMP Parallelization
 Home-page: https://github.com/ksugahar/Radia_NGSolve
 Author: Pascal Elleaume
@@ -296,6 +296,82 @@ export_geometry_to_vtk(mag, 'geometry.vtk')
 - NGSolve (optional, for FEM coupling via radia_ngsolve)
 - PyVista (optional, for 3D visualization)
 
+## Linear Material with External Field (ObjBckgCF)
+
+Radia supports soft magnetic materials (linear materials) in external fields using `ObjBckgCF`.
+
+### Working Example
+
+```python
+import radia as rad
+import numpy as np
+
+rad.UtiDelAll()
+rad.FldUnits('m')  # Use SI units
+
+# Create soft iron cube (10cm side)
+cube = rad.ObjRecMag([0, 0, 0], [0.1, 0.1, 0.1], [0, 0, 0])
+
+# Apply isotropic linear material (mu_r = 100)
+chi = 99.0  # chi = mu_r - 1
+mat = rad.MatLin(chi)  # IMPORTANT: Use single argument for isotropic
+rad.MatApl(cube, mat)
+
+# Create external field (1 Tesla in z-direction)
+def uniform_B(pos):
+    return [0, 0, 1.0]  # Returns B in Tesla
+bg = rad.ObjBckgCF(uniform_B)
+
+# Create system and solve
+system = rad.ObjCnt([cube, bg])
+result = rad.Solve(system, 0.0001, 1000)
+
+# Result: M ~ 2.3 MA/m (correct for cube with mu_r=100 in 1T field)
+M = rad.ObjM(cube)
+print(f"Magnetization: {M[1]} A/m")
+```
+
+### Important Notes
+
+1. **Isotropic materials**: Always use `MatLin(chi)` (single argument)
+   - Do NOT use `MatLin(chi, [0, 0, 1e-10])` - this creates a poorly defined anisotropic tensor
+
+2. **Callback returns B in Tesla**: The callback function for `ObjBckgCF` should return magnetic flux density B in Tesla
+
+3. **Units**: When using `rad.FldUnits('m')`, all coordinates are in meters
+
+4. **Tetrahedral elements**: Also works with `ObjPolyhdr` tetrahedral meshes
+
+### Supported Element Types
+
+| Element | API | External Field Support |
+|---------|-----|----------------------|
+| Hexahedron | `ObjRecMag` | Yes |
+| Tetrahedron | `ObjPolyhdr` | Yes |
+| Extruded Polygon | `ObjThckPgn` | Yes |
+
+## Tetrahedral Mesh Import from NGSolve/Netgen
+
+Radia can import tetrahedral meshes from NGSolve/Netgen for complex geometries.
+
+**Features:**
+- Direct Netgen/OCC mesh import to Radia MMM
+- Independent mesh optimization for FEM vs MMM
+- Nastran CTETRA face connectivity standard
+
+**Usage:** See `examples/cube_uniform_field/linear/` for examples.
+
+**Benchmark** (mu_r=100, B0=1T, 100mm cube):
+
+| Mesh | Elements | M_z (MA/m) | Error |
+|------|----------|------------|-------|
+| 1x1x1 hex | 1 | 2.3171 | 0.00% |
+| 2x2x2 hex | 8 | 2.4180 | 4.36% |
+| 5x5x5 hex | 125 | 2.6652 | 15.02% |
+
+Analytical: M = 2.3171 MA/m (N = 1/3 for cube)
+
+
 ## Changes from Original Radia
 
 ### Removed Components
@@ -379,5 +455,5 @@ See [examples/NGSolve_CoefficientFunction_to_Radia_BackgroundField/](examples/NG
 
 ---
 
-**Version**: 1.0 (OpenMP + NGSolve Edition)
-**Last Updated**: 2025-11-02
+**Version**: 1.3.4 (OpenMP + NGSolve Edition)
+**Last Updated**: 2025-11-30

radia-1.3.7.dist-info/RECORD

@@ -0,0 +1,17 @@
+python/__init__.py,sha256=oUOAjf_vY8DNy5HRU7oArAMic8urvHCR9yHSi4HFkkQ,47
+python/nastran_mesh_import.py,sha256=CSoVhZCXa85lPiTF2hlspE2clBKOD7-_sCp1bxu_IK0,18147
+python/netgen_mesh_import.py,sha256=UopXk-5bbfj1j9_hyiq8jbjb4SQXnWaeuaC7TDf17wA,19872
+python/rad_ngsolve_fast.py,sha256=GkC7ruKy3MESHsO0iRSWsrgLU4-DPPgctOi6pPpsWg4,5675
+python/radia.pyd,sha256=6CNhfoZk5c07LIfeqR6-OT-vT22Oxnc_K3PkTADfa90,1735680
+python/radia_coil_builder.py,sha256=nQkiAbfhueNvvxUARHdPD0C68ImidHmUQv_q4RsImeY,11253
+python/radia_field_cached.py,sha256=Bjw3ecNe3u7AAXnLob5m_tjYIY7HwB9DpgFg9a-aP_8,9509
+python/radia_ngsolve.pyd,sha256=hmPQal8FEqt9Ia5NQ05Vw35RUW5jbWFGQ5PzwXJiLww,566272
+python/radia_ngsolve_field.py,sha256=suJr4wacfYFKOkyV-5AQuHWnW5rtUMb0gSSjq8VRSXc,10166
+python/radia_ngsolve_utils.py,sha256=xZCR9DOIKMwdEjmC28rOXVZiWFY5BQYH2VfopfuVBps,8406
+python/radia_pyvista_viewer.py,sha256=JS33Mx4azGI7hUX0bzefc6zJfhv6qfRjM3Kl1bE9Mjs,4275
+python/radia_vtk_export.py,sha256=I8Vyyt9tky78Qw1xPru9f0Rii6QEmdEgTFjQtamyooc,6540
+radia-1.3.7.dist-info/licenses/LICENSE,sha256=yaWxyzG9DpJ44dDNdGni4nukwiZ8pU-r_aW-1tYNAjk,4374
+radia-1.3.7.dist-info/METADATA,sha256=IpwhuG1ehOREVYTnjk8MQjl3ERnO7Y859KO8ChypMLQ,15518
+radia-1.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+radia-1.3.7.dist-info/top_level.txt,sha256=J-z0poNcsv31IHB413--iOY8LoHBKiTHeybHX3abokI,7
+radia-1.3.7.dist-info/RECORD,,

radia-1.3.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+python

radia/__init__.py

@@ -1,2 +0,0 @@
-# Radia Python package
-__version__ = "1.3.5"

radia/radia_tetra_mesh.py

@@ -1,657 +0,0 @@
-#!/usr/bin/env python
-"""
-radia_tetra_mesh.py - Volume-based tetrahedral mesh solver for Radia
-
-This module provides a specialized solver for tetrahedral meshes with linear
-magnetic materials and background fields. It uses surface-based field computation
-to correctly handle interior face cancellation.
-
-Key features:
-- Surface extraction: Only external faces are used for field computation
-- Interior faces automatically cancel (volume-based approach)
-- Relaxation method for linear material problems
-- Compatible with NGSolve/Netgen tetrahedral meshes
-
-Author: Radia Development Team
-Created: 2025-11-27
-Version: 0.1.0
-
-Example
--------
->>> from ngsolve import Mesh
->>> from netgen.occ import Box, OCCGeometry
->>> import radia as rad
->>> import radia_tetra_mesh as rtm
->>>
->>> rad.FldUnits('m')
->>> geo = OCCGeometry(Box((-0.5, -0.5, -0.5), (0.5, 0.5, 0.5)))
->>> mesh = Mesh(geo.GenerateMesh(maxh=0.2))
->>>
->>> # Solve with linear material in background field
->>> mu_0 = 4 * np.pi * 1e-7
->>> result = rtm.solve_linear_material(
-...     mesh,
-...     chi=99.0,  # mu_r - 1
-...     background_B=[0, 0, mu_0 * 1.0],  # H0 = 1 A/m
-...     precision=0.0001,
-...     max_iter=10000
-... )
-"""
-
-import numpy as np
-import radia as rad
-from ngsolve import VOL, ET
-
-
-# Tetrahedral face topology (0-indexed vertices)
-# v0, v1, v2, v3 are the 4 vertices of the tetrahedron
-TETRA_FACE_VERTICES = [
-    (0, 2, 1),  # Face 0: opposite to v3
-    (0, 1, 3),  # Face 1: opposite to v2
-    (1, 2, 3),  # Face 2: opposite to v0
-    (2, 0, 3)   # Face 3: opposite to v1
-]
-
-
-def extract_surface_faces(mesh, material_filter=None, verbose=True):
-    """
-    Extract external surface faces from tetrahedral mesh.
-
-    Interior faces (shared by two tetrahedra) are identified and excluded.
-    Only external (boundary) faces are returned.
-
-    Parameters
-    ----------
-    mesh : ngsolve.Mesh
-        Input tetrahedral mesh from Netgen/NGSolve
-    material_filter : str or list, optional
-        Filter elements by material name(s)
-    verbose : bool, default=True
-        Print progress information
-
-    Returns
-    -------
-    dict
-        {
-            'surface_faces': list of dict
-                Each face: {
-                    'vertices': [[x1,y1,z1], [x2,y2,z2], [x3,y3,z3]],
-                    'normal': [nx, ny, nz],
-                    'area': float,
-                    'centroid': [cx, cy, cz],
-                    'element_idx': int,  # Parent element index
-                    'local_face_idx': int  # Face index within tetrahedron (0-3)
-                }
-            'elements': list of dict
-                Each element: {
-                    'vertices': [[x1,y1,z1], ..., [x4,y4,z4]],
-                    'centroid': [cx, cy, cz],
-                    'volume': float,
-                    'surface_face_indices': list  # Indices into surface_faces
-                }
-            'interior_face_count': int
-            'surface_face_count': int
-        }
-    """
-    # Normalize material_filter
-    if material_filter is None:
-        allowed_materials = None
-    elif isinstance(material_filter, str):
-        allowed_materials = {material_filter}
-    else:
-        allowed_materials = set(material_filter)
-
-    # First pass: collect all elements and their faces
-    elements = []
-    face_dict = {}  # Key: sorted vertex indices, Value: list of (element_idx, local_face_idx)
-
-    for el_idx, el in enumerate(mesh.Elements(VOL)):
-        if el.type != ET.TET:
-            raise ValueError(f"Element {el_idx} is not tetrahedral (type={el.type})")
-
-        if allowed_materials is not None:
-            if el.mat not in allowed_materials:
-                continue
-
-        # Get vertex coordinates
-        vert_node_ids = el.vertices
-        vertices = []
-        for v_node in vert_node_ids:
-            v = mesh.vertices[v_node.nr]
-            coord = v.point
-            vertices.append([coord[0], coord[1], coord[2]])
-
-        # Compute centroid
-        centroid = [
-            sum(v[0] for v in vertices) / 4.0,
-            sum(v[1] for v in vertices) / 4.0,
-            sum(v[2] for v in vertices) / 4.0
-        ]
-
-        # Compute volume (1/6 * |det([v1-v0, v2-v0, v3-v0])|)
-        v0, v1, v2, v3 = [np.array(v) for v in vertices]
-        vol = abs(np.dot(v1 - v0, np.cross(v2 - v0, v3 - v0))) / 6.0
-
-        el_data = {
-            'vertices': vertices,
-            'centroid': centroid,
-            'volume': vol,
-            'vertex_indices': [v_node.nr for v_node in vert_node_ids],
-            'surface_face_indices': []
-        }
-        elements.append(el_data)
-
-        current_el_idx = len(elements) - 1
-
-        # Process each face
-        for local_face_idx, face_verts in enumerate(TETRA_FACE_VERTICES):
-            # Get global vertex indices for this face
-            global_verts = tuple(sorted([el_data['vertex_indices'][i] for i in face_verts]))
-
-            if global_verts not in face_dict:
-                face_dict[global_verts] = []
-            face_dict[global_verts].append((current_el_idx, local_face_idx))
-
-    # Second pass: identify surface faces (appear only once)
-    surface_faces = []
-    interior_face_count = 0
-
-    for global_verts, occurrences in face_dict.items():
-        if len(occurrences) == 1:
-            # Surface face
-            el_idx, local_face_idx = occurrences[0]
-            el_data = elements[el_idx]
-
-            # Get face vertex coordinates
-            face_vert_indices = TETRA_FACE_VERTICES[local_face_idx]
-            face_vertices = [el_data['vertices'][i] for i in face_vert_indices]
-
-            # Compute face normal and area
-            v0, v1, v2 = [np.array(v) for v in face_vertices]
-            edge1 = v1 - v0
-            edge2 = v2 - v0
-            normal_vec = np.cross(edge1, edge2)
-            area = np.linalg.norm(normal_vec) / 2.0
-
-            if area > 1e-15:
-                normal_unit = normal_vec / (2.0 * area)
-            else:
-                normal_unit = np.array([0.0, 0.0, 1.0])
-
-            # Ensure normal points outward (away from element centroid)
-            face_centroid = (v0 + v1 + v2) / 3.0
-            el_centroid = np.array(el_data['centroid'])
-            outward = face_centroid - el_centroid
-            if np.dot(normal_unit, outward) < 0:
-                normal_unit = -normal_unit
-
-            face_data = {
-                'vertices': face_vertices,
-                'normal': normal_unit.tolist(),
-                'area': area,
-                'centroid': face_centroid.tolist(),
-                'element_idx': el_idx,
-                'local_face_idx': local_face_idx
-            }
-
-            face_idx = len(surface_faces)
-            surface_faces.append(face_data)
-            el_data['surface_face_indices'].append(face_idx)
-
-        elif len(occurrences) == 2:
-            # Interior face - skip
-            interior_face_count += 1
-        else:
-            # Should not happen in valid mesh
-            raise ValueError(f"Face with {len(occurrences)} occurrences (expected 1 or 2)")
-
-    if verbose:
-        print(f"[Surface Extraction]")
-        print(f"  Total elements: {len(elements)}")
-        print(f"  Total faces: {len(face_dict)}")
-        print(f"  Surface faces: {len(surface_faces)}")
-        print(f"  Interior faces: {interior_face_count} (excluded)")
-
-    return {
-        'surface_faces': surface_faces,
-        'elements': elements,
-        'interior_face_count': interior_face_count,
-        'surface_face_count': len(surface_faces)
-    }
-
-
-def compute_h_field_from_surface_charge(obs_point, faces, magnetizations, element_map):
-    """
-    Compute H field at observation point from surface magnetic charges.
-
-    The surface charge density on each face is sigma = M . n, where M is the
-    magnetization of the parent element and n is the outward face normal.
-
-    Parameters
-    ----------
-    obs_point : array-like
-        Observation point [x, y, z]
-    faces : list
-        List of surface face dictionaries
-    magnetizations : ndarray
-        Magnetization vectors for each element, shape (n_elements, 3)
-    element_map : list
-        Maps face index to parent element index
-
-    Returns
-    -------
-    ndarray
-        H field vector [Hx, Hy, Hz] in A/m
-    """
-    obs = np.array(obs_point)
-    H = np.zeros(3)
-
-    for face_idx, face in enumerate(faces):
-        el_idx = face['element_idx']
-        M = magnetizations[el_idx]
-        n = np.array(face['normal'])
-
-        # Surface charge density: sigma = M . n
-        sigma = np.dot(M, n)
-
-        if abs(sigma) < 1e-20:
-            continue
-
-        # Face centroid
-        face_center = np.array(face['centroid'])
-
-        # Vector from face to observation point
-        r_vec = obs - face_center
-        r_mag = np.linalg.norm(r_vec)
-
-        if r_mag < 1e-15:
-            # Observation point at face centroid - use simplified formula
-            # H_local = -sigma / 2 * n (for field inside material)
-            continue
-
-        # H = sigma * Area / (4 * pi * r^2) * r_hat
-        # This is the monopole approximation for far field
-        area = face['area']
-        factor = sigma * area / (4.0 * np.pi * r_mag**3)
-        H += factor * r_vec
-
-    return H
-
-
-def compute_interaction_matrix(mesh_data, verbose=True):
-    """
-    Compute interaction matrix for relaxation solver.
-
-    The interaction matrix A[i,j] gives the H field at element i's centroid
-    due to a unit magnetization in element j (through surface charges).
-
-    For linear materials: H_total = A @ M + H_ext
-
-    Parameters
-    ----------
-    mesh_data : dict
-        Output from extract_surface_faces()
-    verbose : bool, default=True
-        Print progress
-
-    Returns
-    -------
-    ndarray
-        Interaction matrix, shape (3*n_elements, 3*n_elements)
-        Organized as [Hx_0, Hy_0, Hz_0, Hx_1, Hy_1, Hz_1, ...]
-    """
-    elements = mesh_data['elements']
-    faces = mesh_data['surface_faces']
-    n_elements = len(elements)
-
-    if verbose:
-        print(f"[Interaction Matrix]")
-        print(f"  Building {3*n_elements} x {3*n_elements} matrix...")
-
-    # For each source element, set unit M in x, y, z directions
-    # and compute H at all observation points
-    A = np.zeros((3 * n_elements, 3 * n_elements))
-
-    # Progress tracking
-    total_ops = n_elements * 3
-    progress_interval = max(1, total_ops // 10)
-
-    for src_el in range(n_elements):
-        for src_comp in range(3):  # Mx, My, Mz
-            col_idx = 3 * src_el + src_comp
-
-            # Unit magnetization in direction src_comp
-            M_test = np.zeros((n_elements, 3))
-            M_test[src_el, src_comp] = 1.0
-
-            # Compute H at all element centroids
-            for obs_el in range(n_elements):
-                obs_point = elements[obs_el]['centroid']
-                H = compute_h_field_from_surface_charge(obs_point, faces, M_test, None)
-
-                for obs_comp in range(3):
-                    row_idx = 3 * obs_el + obs_comp
-                    A[row_idx, col_idx] = H[obs_comp]
-
-            if verbose and (col_idx + 1) % progress_interval == 0:
-                print(f"  Progress: {100*(col_idx+1)/total_ops:.0f}%")
-
-    if verbose:
-        print(f"  Matrix construction complete")
-
-    return A
-
-
-def solve_linear_material(mesh, chi, background_B, precision=0.0001, max_iter=10000,
-                          material_filter=None, relax_param=0.5, verbose=True):
-    """
-    Solve for magnetization in linear magnetic material with background field.
-
-    Uses relaxation method to solve: M = chi * H_total
-    where H_total = H_background + H_demagnetizing(M)
-
-    Parameters
-    ----------
-    mesh : ngsolve.Mesh
-        Input tetrahedral mesh
-    chi : float
-        Magnetic susceptibility (chi = mu_r - 1)
-    background_B : array-like
-        Background magnetic field [Bx, By, Bz] in Tesla
-    precision : float, default=0.0001
-        Convergence precision (relative change in M)
-    max_iter : int, default=10000
-        Maximum iterations
-    material_filter : str or list, optional
-        Filter elements by material name
-    relax_param : float, default=0.5
-        Relaxation parameter (0 < relax_param <= 1)
-        Smaller values = more stable but slower convergence
-    verbose : bool, default=True
-        Print progress information
-
-    Returns
-    -------
-    dict
-        {
-            'magnetizations': ndarray, shape (n_elements, 3)
-                Final magnetization vectors for each element
-            'H_fields': ndarray, shape (n_elements, 3)
-                H field at each element centroid
-            'iterations': int
-                Number of iterations performed
-            'converged': bool
-                Whether solution converged
-            'mesh_data': dict
-                Surface extraction data
-            'final_residual': float
-                Final relative residual
-        }
-    """
-    mu_0 = 4.0 * np.pi * 1e-7
-
-    # Convert background B to H
-    B0 = np.array(background_B)
-    H0 = B0 / mu_0
-
-    if verbose:
-        print("=" * 60)
-        print("Volume-based Tetrahedral Mesh Solver")
-        print("=" * 60)
-        print(f"Parameters:")
-        print(f"  chi = {chi} (mu_r = {chi + 1})")
-        print(f"  Background H0 = {H0} A/m")
-        print(f"  Precision = {precision}")
-        print(f"  Max iterations = {max_iter}")
-        print()
-
-    # Extract surface faces
-    mesh_data = extract_surface_faces(mesh, material_filter=material_filter, verbose=verbose)
-    elements = mesh_data['elements']
-    faces = mesh_data['surface_faces']
-    n_elements = len(elements)
-
-    if n_elements == 0:
-        raise ValueError("No elements found in mesh")
-
-    if verbose:
-        print()
-
-    # Compute interaction matrix
-    A = compute_interaction_matrix(mesh_data, verbose=verbose)
-
-    if verbose:
-        print()
-        print("[Relaxation Solver]")
-        print(f"  Starting iteration...")
-
-    # Initialize magnetizations to chi * H0
-    M = np.zeros((n_elements, 3))
-    for i in range(n_elements):
-        M[i] = chi * H0
-
-    # External field array (same for all elements)
-    H_ext = np.tile(H0, n_elements)  # Shape: (3*n_elements,)
-
-    # Relaxation iteration
-    converged = False
-    final_residual = np.inf
-
-    for iteration in range(max_iter):
-        # Flatten M for matrix multiplication
-        M_flat = M.flatten()
-
-        # Compute H_total = A @ M + H_ext
-        H_demag = A @ M_flat
-        H_total = H_demag + H_ext
-
-        # Compute new M from material relation: M_new = chi * H_total
-        M_new_flat = chi * H_total
-        M_new = M_new_flat.reshape((n_elements, 3))
-
-        # Apply relaxation
-        M_update = (1.0 - relax_param) * M + relax_param * M_new
-
-        # Check convergence
-        dM = M_update - M
-        residual = np.sqrt(np.sum(dM**2) / n_elements)
-        M_norm = np.sqrt(np.sum(M**2) / n_elements)
-
-        if M_norm > 1e-15:
-            rel_residual = residual / M_norm
-        else:
-            rel_residual = residual
-
-        M = M_update
-        final_residual = rel_residual
-
-        if verbose and (iteration + 1) % 100 == 0:
-            print(f"    Iter {iteration+1}: residual = {rel_residual:.6e}")
-
-        if rel_residual < precision:
-            converged = True
-            if verbose:
-                print(f"    Converged at iteration {iteration+1}")
-            break
-
-    if not converged and verbose:
-        print(f"    [WARNING] Did not converge after {max_iter} iterations")
-        print(f"    Final residual: {final_residual:.6e}")
-
-    # Compute final H fields
-    H_fields = np.zeros((n_elements, 3))
-    M_flat = M.flatten()
-    H_demag = A @ M_flat
-    for i in range(n_elements):
-        H_fields[i] = H_demag[3*i:3*i+3] + H0
-
-    if verbose:
-        print()
-        print("[Results]")
-        # Average M and H
-        M_avg = np.mean(M, axis=0)
-        H_avg = np.mean(H_fields, axis=0)
-        print(f"  Average M: ({M_avg[0]:.6f}, {M_avg[1]:.6f}, {M_avg[2]:.6f}) A/m")
-        print(f"  Average H: ({H_avg[0]:.6f}, {H_avg[1]:.6f}, {H_avg[2]:.6f}) A/m")
-        print(f"  H at center element: ({H_fields[0][0]:.6f}, {H_fields[0][1]:.6f}, {H_fields[0][2]:.6f}) A/m")
-
-    return {
-        'magnetizations': M,
-        'H_fields': H_fields,
-        'iterations': iteration + 1,
-        'converged': converged,
-        'mesh_data': mesh_data,
-        'final_residual': final_residual,
-        'elements': elements
-    }
-
-
-def evaluate_field(result, point, include_background=True):
-    """
-    Evaluate H field at arbitrary point using solved magnetization.
-
-    Parameters
-    ----------
-    result : dict
-        Output from solve_linear_material()
-    point : array-like
-        Evaluation point [x, y, z]
-    include_background : bool, default=True
-        Whether to include background field in result
-
-    Returns
-    -------
-    ndarray
-        H field vector [Hx, Hy, Hz] in A/m
-    """
-    mesh_data = result['mesh_data']
-    faces = mesh_data['surface_faces']
-    M = result['magnetizations']
-
-    H = compute_h_field_from_surface_charge(point, faces, M, None)
-
-    # Background field is implicit in the solved M, but for external evaluation
-    # we need to add it back if requested
-    # Actually, the H_fields already include background, so we don't need to do anything
-
-    return H
-
-
-def create_radia_container(result, apply_magnetization=True):
-    """
-    Create Radia container from solved result for field evaluation.
-
-    Parameters
-    ----------
-    result : dict
-        Output from solve_linear_material()
-    apply_magnetization : bool, default=True
-        If True, apply solved magnetizations to Radia objects
-
-    Returns
-    -------
-    int
-        Radia container object ID
-    """
-    from netgen_mesh_import import TETRA_FACES
-
-    elements = result['elements']
-    M = result['magnetizations']
-
-    obj_ids = []
-    for el_idx, el in enumerate(elements):
-        vertices = el['vertices']
-        mag = M[el_idx].tolist() if apply_magnetization else [0, 0, 0]
-
-        obj_id = rad.ObjPolyhdr(vertices, TETRA_FACES, mag)
-        obj_ids.append(obj_id)
-
-    container = rad.ObjCnt(obj_ids)
-    return container
-
-
-# Convenience function for common use case
-def solve_cube_in_field(cube_size, chi, H0_z, mesh_size=None, **kwargs):
-    """
-    Convenience function to solve a cube of linear material in uniform H field.
-
-    Parameters
-    ----------
-    cube_size : float
-        Full size of cube (centered at origin)
-    chi : float
-        Magnetic susceptibility (chi = mu_r - 1)
-    H0_z : float
-        z-component of background H field in A/m
-    mesh_size : float, optional
-        Maximum element size. Default: cube_size / 5
-    **kwargs
-        Additional arguments passed to solve_linear_material()
-
-    Returns
-    -------
-    dict
-        Result from solve_linear_material()
-    """
-    from ngsolve import Mesh
-    from netgen.occ import Box, Pnt, OCCGeometry
-
-    half = cube_size / 2.0
-    if mesh_size is None:
-        mesh_size = cube_size / 5.0
-
-    mu_0 = 4.0 * np.pi * 1e-7
-    B0 = [0, 0, mu_0 * H0_z]
-
-    cube_geo = Box(Pnt(-half, -half, -half), Pnt(half, half, half))
-    geo = OCCGeometry(cube_geo)
-    ngmesh = geo.GenerateMesh(maxh=mesh_size)
-    mesh = Mesh(ngmesh)
-
-    return solve_linear_material(mesh, chi, B0, **kwargs)
-
-
-if __name__ == "__main__":
-    # Test with cube in uniform field (same as NGSolve reference)
-    print("Testing volume-based tetrahedral solver")
-    print("=" * 60)
-    print()
-
-    # Parameters matching NGSolve reference
-    cube_size = 1.0  # 1m cube
-    mu_r = 100
-    chi = mu_r - 1.0
-    H0 = 1.0  # A/m
-
-    rad.FldUnits('m')
-
-    result = solve_cube_in_field(
-        cube_size=cube_size,
-        chi=chi,
-        H0_z=H0,
-        mesh_size=0.25,
-        precision=0.0001,
-        max_iter=1000,
-        relax_param=0.3  # Slower but more stable
-    )
-
-    print()
-    print("=" * 60)
-    print("Comparison with NGSolve reference:")
-    print("=" * 60)
-    print(f"NGSolve Hz_total at origin: 0.034702 A/m")
-
-    # Find element closest to origin
-    min_dist = np.inf
-    center_el_idx = 0
-    for i, el in enumerate(result['elements']):
-        dist = np.linalg.norm(el['centroid'])
-        if dist < min_dist:
-            min_dist = dist
-            center_el_idx = i
-
-    Hz_center = result['H_fields'][center_el_idx][2]
-    print(f"Our Hz at center element: {Hz_center:.6f} A/m")
-    print(f"Difference: {abs(Hz_center - 0.034702):.6f} A/m")
-    if Hz_center > 1e-6:
-        print(f"Relative error: {abs(Hz_center - 0.034702) / 0.034702 * 100:.2f}%")

radia-1.3.5.dist-info/RECORD

@@ -1,18 +0,0 @@
-radia/__init__.py,sha256=edxD1jM_-2LddwoxqtgATa_vTaruXk5WZsntpFJ9qtM,47
-radia/nastran_mesh_import.py,sha256=CSoVhZCXa85lPiTF2hlspE2clBKOD7-_sCp1bxu_IK0,18147
-radia/netgen_mesh_import.py,sha256=UopXk-5bbfj1j9_hyiq8jbjb4SQXnWaeuaC7TDf17wA,19872
-radia/rad_ngsolve.pyd,sha256=s5ZvpTIrjYeV_B3vQv5HrtP4u_RaPhvxuZf5aKv3oC0,566272
-radia/rad_ngsolve_fast.py,sha256=GkC7ruKy3MESHsO0iRSWsrgLU4-DPPgctOi6pPpsWg4,5675
-radia/radia_coil_builder.py,sha256=nQkiAbfhueNvvxUARHdPD0C68ImidHmUQv_q4RsImeY,11253
-radia/radia_field_cached.py,sha256=Bjw3ecNe3u7AAXnLob5m_tjYIY7HwB9DpgFg9a-aP_8,9509
-radia/radia_ngsolve.pyd,sha256=s5ZvpTIrjYeV_B3vQv5HrtP4u_RaPhvxuZf5aKv3oC0,566272
-radia/radia_ngsolve_field.py,sha256=suJr4wacfYFKOkyV-5AQuHWnW5rtUMb0gSSjq8VRSXc,10166
-radia/radia_ngsolve_utils.py,sha256=xZCR9DOIKMwdEjmC28rOXVZiWFY5BQYH2VfopfuVBps,8406
-radia/radia_pyvista_viewer.py,sha256=JS33Mx4azGI7hUX0bzefc6zJfhv6qfRjM3Kl1bE9Mjs,4275
-radia/radia_tetra_mesh.py,sha256=nEpNpOBdJ-0DjS7WUx_bRHskrDKSKH3rSEWr-CwyQRM,21147
-radia/radia_vtk_export.py,sha256=I8Vyyt9tky78Qw1xPru9f0Rii6QEmdEgTFjQtamyooc,6540
-radia-1.3.5.dist-info/licenses/LICENSE,sha256=yaWxyzG9DpJ44dDNdGni4nukwiZ8pU-r_aW-1tYNAjk,4374
-radia-1.3.5.dist-info/METADATA,sha256=LuqDACqJI2J9ucBkZe1UQFfh77ZuYnZvZIwI9JwRpX0,13202
-radia-1.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-radia-1.3.5.dist-info/top_level.txt,sha256=kNDonE5X3Q2xnmOsWleQnGKQobuFsKM6Px5_Ta1I6x8,6
-radia-1.3.5.dist-info/RECORD,,

radia-1.3.5.dist-info/top_level.txt

@@ -1 +0,0 @@
-radia