femagtools 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.2'
+__version__ = '1.8.4'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2024 Gamma Technology'

femagtools/bch.py

@@ -307,14 +307,14 @@ class Reader:
                 self.torque_fft = [
                     {'order': order.tolist(),
                      'torque': tq.tolist()}]
-        except (KeyError, IndexError):
+        except (KeyError, IndexError, ValueError):
             pass
-        
+
         # check number of phases
-        try: 
+        try:
             if 'm' not in self.machine:
                 self.machine['m'] = len(self.current_angles)
-        except: 
+        except:
             pass
 
         return self
@@ -1439,17 +1439,21 @@ class Reader:
                                 'psid', 'psiq', 'torque')
                 except:
                     pass
-        if self.dqPar['psim']:
+        if self.dqPar.get('psim', 0):
             self.dqPar.pop('up', None)
         else:
+            up = np.array(self.dqPar.pop('up', None))
             self.dqPar.pop('psim', None)
+
         try:
             w1 = np.pi*self.dqPar['speed']*self.dqPar['npoles']
             r1 = self.machine.get('r1', 0.0)
             beta = np.array(self.dqPar['beta'])/180*np.pi
             iq = np.cos(beta)*self.dqPar['i1']
             id = np.sin(beta)*self.dqPar['i1']
-            up = w1*np.array(self.dqPar['psim'])
+            if 'psim' in self.dqPar:
+                up = w1*np.array(self.dqPar['psim'])
+
             ld = np.array(self.dqPar['ld'])
             lq = np.array(self.dqPar['lq'])
             uq = r1*iq + up + id*w1*ld

femagtools/dxfsl/area.py

@@ -12,6 +12,7 @@ import numpy as np
 import networkx as nx
 import logging
 from .functions import less_equal, less, greater_equal, greater
+from .functions import greater_angle, less_angle
 from .functions import distance, alpha_angle, alpha_line, min_angle, max_angle
 from .functions import point, line_m, line_n, intersect_point, points_are_close
 from .functions import middle_angle, part_of_circle, is_same_angle
@@ -75,6 +76,10 @@ class Area(object):
         self.start = 0.0
         self.sym_startangle = 0.0
         self.sym_endangle = 0.0
+        self.sym_upper_left_dist = None
+        self.sym_upper_right_dist = None
+        self.sym_lower_left_dist = None
+        self.sym_lower_right_dist = None
         self.sym_type = 0
         self.symmetry = 0
         self.sym_tolerance = sym_tolerance
@@ -636,7 +641,10 @@ class Area(object):
     def get_alpha(self, center):
         if self.center_is_inside(center):
             return np.pi*2.0
-        return alpha_angle(self.min_angle, self.max_angle)
+        return alpha_angle(self.min_angle,
+                           self.max_angle,
+                           rtol=0.0,
+                           atol=0.0)
 
     def get_mid_angle(self, center):
         if self.center_is_inside(center):
@@ -674,6 +682,66 @@ class Area(object):
             return True
         return False
 
+    def set_symmetry_parameter(self, center):
+        all_list = [(distance(center, n), alpha_line(center, n))
+                    for n in self.list_of_nodes()]
+        mid = middle_angle(self.min_angle, self.max_angle)
+        left_list = [(d, a) for d, a in all_list if greater_angle(a, mid)]
+        right_list = [(d, a) for d, a in all_list if less_angle(a, mid)]
+        left_list.sort()
+        right_list.sort()
+
+        if left_list:
+            l_low_d, l_low_a = left_list[0]
+            l_up_d, l_up_a = left_list[-1]
+        else:
+            l_low_d = self.min_dist
+            l_up_d = self.max_dist
+        if right_list:
+            r_low_d, r_low_a = right_list[0]
+            r_up_d, r_up_a = right_list[-1]
+        else:
+            r_low_d = self.min_dist
+            r_up_d = self.max_dist
+        self.sym_upper_left_dist = l_up_d
+        self.sym_upper_right_dist = r_up_d
+        self.sym_lower_left_dist = l_low_d
+        self.sym_lower_right_dist = r_low_d
+
+    def is_symmetry_equal(self, area):
+        logger.debug("check area %s -- %s", self.get_id(), area.get_id())
+
+        bad = False
+        if not np.isclose(self.sym_lower_left_dist, area.sym_lower_left_dist,
+                           rtol=5e-1, atol=5e-1):
+            logger.debug("Lower left: %s != %s",
+                         self.sym_lower_left_dist,
+                         area.sym_lower_left_dist)
+            bad = True
+
+        if not np.isclose(self.sym_lower_right_dist, area.sym_lower_right_dist,
+                          rtol=5e-1, atol=5e-1):
+            logger.debug("Lower right: %s != %s",
+                         self.sym_lower_right_dist,
+                         area.sym_lower_right_dist)
+            bad = True
+
+        if not np.isclose(self.sym_upper_left_dist, area.sym_upper_left_dist,
+                          rtol=5e-1, atol=5e-1):
+            logger.debug("Upper left: %s != %s",
+                         self.sym_upper_left_dist,
+                         area.sym_upper_left_dist)
+            bad = True
+
+        if not np.isclose(self.sym_upper_right_dist, area.sym_upper_right_dist,
+                          rtol=5e-1, atol=5e-1):
+            logger.debug("Upper right: %s != %s",
+                         self.sym_upper_right_dist,
+                         area.sym_upper_right_dist)
+            bad = True
+
+        return not bad
+
     def increment(self, a):
         if self.is_identical(a):
             return

femagtools/dxfsl/conv.py

@@ -18,8 +18,18 @@ logger = logging.getLogger(__name__)
 def main():
     argparser = argparse.ArgumentParser(
         description='Process DXF file and create a plot or FSL file.')
+    super_help = "--Help" in sys.argv
+    if super_help:
+        sys.argv.append("--help")
+
     argparser.add_argument('dxfile',
                            help='name of DXF file')
+    argparser.add_argument('--Help',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 "show this extended help message and exit"),
+                           dest='Help',
+                           action="store_true",
+                           default=False)
     argparser.add_argument('--PMSM',
                            help='Permanent Magnet Synchronous Motor',
                            dest='PMSM',
@@ -47,47 +57,56 @@ def main():
                            dest='stator',
                            default='')
     argparser.add_argument('--sympart',
-                           help='forced symmetry part',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'forced symmetry part'),
                            dest='sym_part',
                            type=int,
                            default=0)
     argparser.add_argument('-a', '--airgap',
-                           help='correct airgap',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'correct airgap'),
                            dest='airgap',
                            type=float,
                            default=0.0)
     argparser.add_argument('--airgap2',
-                           help='correct airgap',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'correct airgap'),
                            dest='airgap2',
                            type=float,
                            default=0.0)
     argparser.add_argument('-t', '--symtol',
-                           help='absolut tolerance to find symmetry axis',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'absolut tolerance to find symmetry axis'),
                            dest='sym_tolerance',
                            type=float,
                            default=0.001)
     argparser.add_argument('--mindist',
-                           help='minimal distance of spline control-points',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'minimal distance of spline control-points'),
                            dest='mindist',
                            type=float,
                            default=0.01)
     argparser.add_argument('--rtol',
-                           help='relative tolerance (pickdist)',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'relative tolerance (pickdist)'),
                            dest='rtol',
                            type=float,
                            default=1e-04)
     argparser.add_argument('--atol',
-                           help='absolut tolerance (pickdist)',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'absolut tolerance (pickdist)'),
                            dest='atol',
                            type=float,
                            default=1e-03)
     argparser.add_argument('--da',
-                           help='distance airgap',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'distance airgap'),
                            dest='da',
                            type=float,
                            default=0.0)
     argparser.add_argument('--dy',
-                           help='distance yoke',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'distance yoke'),
                            dest='dy',
                            type=float,
                            default=0.0)
@@ -104,27 +123,36 @@ def main():
                            dest='small_plots',
                            action="store_true")
     argparser.add_argument('--areas',
-                           help='show all areas',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'show all areas with single plots'),
                            dest='show_areas',
                            action="store_true")
     argparser.add_argument('--id',
-                           help='write id of areas',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'write id of areas into the plot'),
                            dest='write_id',
                            action="store_true")
     argparser.add_argument('-f', '--fsl',
                            help='create fsl',
                            dest='write_fsl',
                            action="store_true")
+    argparser.add_argument('--fsl_single',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'create separate fsl for rotor and stator'),
+                           dest='write_fsl_single',
+                           action="store_true")
     argparser.add_argument('-v', '--view',
                            help='show a view only',
                            dest='view',
                            action="store_true")
     argparser.add_argument('-k', '--korr',
-                           help='show a view with korrections',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'show a view with korrections'),
                            dest='view_korr',
                            action="store_true")
     argparser.add_argument('--png',
-                           help='write png-file only',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'write plot in png-file only'),
                            dest='write_png',
                            action="store_true")
     argparser.add_argument('-d', '--debug',
@@ -135,8 +163,9 @@ def main():
                            help='print information in logfile and set --debug',
                            dest='debug',
                            action="store_true")
-    argparser.add_argument('-j',
-                           help='print information in journal file',
+    argparser.add_argument('--journal',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 'print information in journal file'),
                            dest='journal',
                            action="store_true")
     argparser.add_argument('--version',
@@ -151,6 +180,12 @@ def main():
                            help='create full model (fsl only)',
                            dest='full_model',
                            action="store_true")
+    argparser.add_argument('--no_processing',
+                           help=(argparse.SUPPRESS if not super_help else
+                                 "omit multiprocessing"),
+                           dest='no_processing',
+                           action="store_true",
+                           default=False)
 
     args = argparser.parse_args()
 
@@ -242,11 +277,13 @@ def main():
                   show_areas=args.show_areas,
                   small_plots=args.small_plots,
                   write_fsl=args.write_fsl,
+                  write_fsl_single=args.write_fsl_single,
                   write_png=args.write_png,
                   write_id=args.write_id,
                   debug_mode=args.debugger,
                   full_model=args.full_model,
-                  write_journal=args.journal)
+                  write_journal=args.journal,
+                  no_processing=args.no_processing)
     keys = ('tot_num_slot', 'num_sl_gen', 'num_poles', 'nodedist',
             'dy1', 'da1', 'da2', 'dy2', 'agndst', 'name')
     logger.info("%s", {k: res[k] for k in keys if k in res})