Fem testing (#1)

* loop-loop test

* sdfsdf

* fix test

* add FEM test magnet-loop

* replace mesh with meshing

* interface + test update

* adjust force output shape

Author: OrtnerMichael

magpylib_force/__init__.py

@@ -1,14 +1,12 @@
-from magpylib_force.force import getFTcube
-from magpylib_force.force import getFTwire
+from magpylib_force.force import getFT
 
 """
 The magpylib-force package sits on top of magpylib for force computation
 """
 
 # module level dunders
-__version__ = "0.1.6"
+__version__ = "0.1.8"
 __author__ = "SAL"
 __all__ = [
-    "getFTcube",
-    "getFTwire",
+    "getFT",
 ]

magpylib_force/force.py

@@ -1,9 +1,77 @@
 import numpy as np
 import magpylib as magpy
-from magpylib_force.mesh import mesh_cuboid
+from magpylib_force.meshing import mesh_cuboid
 from magpylib_force.utility import check_input_anchor
-from magpylib_force.utility import check_input_targets_Cuboid
-from magpylib_force.utility import check_input_targets_Polyline
+from magpylib_force.utility import check_input_targets
+from magpylib._src.obj_classes.class_current_Polyline import Polyline
+from magpylib._src.obj_classes.class_magnet_Cuboid import Cuboid
+
+
+def getFT(sources, targets, anchor=None, eps=1e-5, squeeze=True):
+    """
+    Compute force and torque between sources and targets.
+    SI units are assumed for all inputs and outputs.
+
+    Parameters
+    ----------
+    sources: source and collection objects or 1D list thereof
+        Sources that generate the magnetic field. Can be a single source (or collection)
+        or a 1D list of l sources and/or collection objects.
+
+    targets: single object or 1D list of t objects that are in [Cuboid, Polyline]
+        Force and Torque acting on targets in the magnetic field generated by the sources
+        will be computed. A target must have a valid `meshing` parameter.
+    
+    eps: float, default=1e-5
+        For magnet-targets the magnetic field gradient is computed using finite
+        differences (FD). `eps` is the FD step size. A good value
+        is 1e-5 * characteristic system size (magnet size, distance between sources
+        and targets, ...).
+
+    anchor: array_like, default=None
+        The Force adds to the Torque via the anchor point. For a freely floating magnet
+        this would be the barycenter. If `anchor=None`, this part of the Torque computation
+        is ommitted.
+
+    squeeze: bool, default=True
+        The output of the computation has the shape (n,3) where n corresponds to the number
+        of targets. By default this is reduced to (3,) when there is only one target.
+
+    Returns
+    -------
+    Force-Torque as ndarray of shape (2,3), of (t,2,3) when t targets are given
+    """
+    anchor = check_input_anchor(anchor)
+    targets = check_input_targets(targets)
+    # MISSING: allow Collections
+
+    n = len(targets)
+
+    cuboids, order_cub = [], []
+    polylines, order_poly = [], []
+    for i,t in enumerate(targets):
+        if isinstance(t, Cuboid):
+            cuboids.append(t)
+            order_cub.append(i)
+        elif isinstance(t, Polyline):
+            polylines.append(t)
+            order_poly.append(i)
+
+    FT = np.zeros((n, 2, 3))
+    if cuboids:
+        FT_cube = getFTcube(sources, cuboids, eps=eps, anchor=anchor, squeeze=False)
+        FT_cube = np.swapaxes(FT_cube, 0, 1)
+        for ft,o in zip(FT_cube, order_cub):
+            FT[o] = ft
+    if polylines:
+        FT_poly = getFTwire(sources, polylines, anchor=anchor, squeeze=False)
+        FT_poly = np.swapaxes(FT_poly, 0, 1)
+        for ft,o in zip(FT_poly, order_poly):
+            FT[o] = ft
+    #FT = np.swapaxes(FT, 0, 1)
+    if squeeze:
+        return np.squeeze(FT)
+    return FT
 
 
 def getFTcube(sources, targets, eps=1e-5, anchor=None, squeeze=True):
@@ -18,7 +86,7 @@ def getFTcube(sources, targets, eps=1e-5, anchor=None, squeeze=True):
 
     targets: Cuboid object or 1D list of Cuboid objects
         Force and Torque acting on targets in the magnetic field generated by the sources
-        will be computed. A target must have a valid mesh parameter.
+        will be computed. A target must have a valid `meshing` parameter.
     
     eps: float, default=1e-5
         The magnetic field gradient is computed using finite differences (FD). eps is
@@ -34,15 +102,12 @@ def getFTcube(sources, targets, eps=1e-5, anchor=None, squeeze=True):
         The output of the computation has the shape (n,3) where n corresponds to the number
         of targets. By default this is reduced to (3,) when there is only one target.
     """
-    anchor = check_input_anchor(anchor)
-    targets = check_input_targets_Cuboid(targets)
-    # MISSING: allow Collections
 
     # number of Cuboids
     tgt_number = len(targets)
 
     # number of instances of each Cuboid
-    inst_numbers = np.array([np.prod(tgt.mesh) for tgt in targets])
+    inst_numbers = np.array([np.prod(tgt.meshing) for tgt in targets])
 
     # total number of instances
     no_inst = np.sum(inst_numbers)
@@ -85,7 +150,7 @@ def getFTcube(sources, targets, eps=1e-5, anchor=None, squeeze=True):
         F = np.squeeze(F)
         T = np.squeeze(T)
 
-    return F, T
+    return np.array((F, T))
 
 
 
@@ -96,21 +161,17 @@ def getFTwire(sources, targets, anchor=None, squeeze=True):
     info:
     targets = Polyline objects
     segements = linear segments within Polyline objects
-    instances = computation instances, each segment is split into `mesh` points
+    instances = computation instances, each segment is split into `meshing` points
     """
 
-    anchor = check_input_anchor(anchor)
-    targets = check_input_targets_Polyline(targets)
-    # MISSING: allow Collections
-
     # number of Polylines
     tgt_number = len(targets)
 
     # segments of each Polyline
     seg_numbers = np.array([len(tgt.vertices)-1 for tgt in targets])
 
     # number of mesh-points of each Polyline
-    mesh_numbers = np.array([tgt.mesh for tgt in targets])
+    mesh_numbers = np.array([tgt.meshing for tgt in targets])
 
     # number of instances of each Polyline
     inst_numbers = seg_numbers*mesh_numbers
@@ -152,7 +213,7 @@ def getFTwire(sources, targets, anchor=None, squeeze=True):
         T = np.cross(anchor - POSS, F)
         T = np.array([np.sum(T[insti[i]:insti[i+1]],axis=0) for i in range(tgt_number)])
     else:
-        T = np.zeros((tgt_number,))
+        T = np.zeros((tgt_number,3))
 
     # sumup force for every target
     F = np.array([np.sum(F[insti[i]:insti[i+1]],axis=0) for i in range(tgt_number)])
@@ -162,4 +223,4 @@ def getFTwire(sources, targets, anchor=None, squeeze=True):
         F = np.squeeze(F)
         T = np.squeeze(T)
 
-    return F, T
+    return np.array((F, T))

magpylib_force/mesh.py renamed to magpylib_force/meshing.py

@@ -9,7 +9,7 @@ def mesh_cuboid(object):
     returns grid positions relative to cuboid position
     """
     a,b,c = object.dimension
-    n1,n2,n3 = object.mesh
+    n1,n2,n3 = object.meshing
     xs = np.linspace(-a/2, a/2, n1+1)
     ys = np.linspace(-b/2, b/2, n2+1)
     zs = np.linspace(-c/2, c/2, n3+1)
@@ -52,7 +52,7 @@ def mesh_cuboid_old2(object, verbose=False):
     grid positions: np.ndarray shape (m,3)
     """
     a,b,c = object.dimension
-    splitting = object.mesh
+    splitting = object.meshing
     if isinstance(splitting, (float, int)):
         x = (a*b*c/splitting)**(1/3)
         n1 = m.ceil(a/x)

magpylib_force/utility.py

@@ -18,19 +18,37 @@ def check_input_anchor(anchor):
     return anchor
 
 
-def check_input_targets_Cuboid(targets):
+def check_input_targets(targets):
     """ check and format targets input """
-    if isinstance(targets, Cuboid):
-        targets = [targets]
     if not isinstance(targets, list):
-        raise ValueError("Bad targets input.")
+        targets = [targets]
+    for t in targets:
+        if not isinstance(t, (Cuboid, Polyline)):
+            raise ValueError(
+                "Bad `targets` input for getFT."
+                " `targets` can only be Cuboids and Polylines."
+                f" Instead receivd type {type(t)} target."
+            )
+        if not hasattr(t, "meshing"):
+            raise ValueError(
+                "Bad `targets` input for getFT."
+                " `targets` must have the `meshing` parameter set."
+            )
     return targets
 
+# def check_input_targets_Cuboid(targets):
+#     """ check and format targets input """
+#     if isinstance(targets, Cuboid):
+#         targets = [targets]
+#     if not isinstance(targets, list):
+#         raise ValueError("Bad targets input.")
+#     return targets
 
-def check_input_targets_Polyline(targets):
-    """ check and format targets input """
-    if isinstance(targets, Polyline):
-        targets = [targets]
-    if not isinstance(targets, list):
-        raise ValueError("Bad targets input.")
-    return targets
+
+# def check_input_targets_Polyline(targets):
+#     """ check and format targets input """
+#     if isinstance(targets, Polyline):
+#         targets = [targets]
+#     if not isinstance(targets, list):
+#         raise ValueError("Bad targets input.")
+#     return targets

requirements.txt

@@ -1 +1 @@
-magpylib>=5.0.1
+magpylib>=5.0.1