femagtools 1.6.8__py3-none-any.whl → 1.7.1__py3-none-any.whl

femagtools/dxfsl/areabuilder.py

@@ -12,7 +12,7 @@ import logging
 import sys
 from femagtools.dxfsl.shape import Element, Shape, Circle, Arc, Line
 from femagtools.dxfsl.shape import is_Circle, is_Arc, is_Line
-from femagtools.dxfsl.area import Area
+from femagtools.dxfsl.area import Area, TYPE_AIR
 from femagtools.dxfsl.functions import points_are_close, nodes_are_equal, distance
 from femagtools.dxfsl.functions import normalise_angle, positive_angle, point
 from femagtools.dxfsl.functions import alpha_line, alpha_points, alpha_angle
@@ -33,7 +33,7 @@ def disable_logging():
     logger.debug("Logging level %s disabled", original_log_level)
 
     # Set the log level to a higher level, e.g., WARNING or CRITICAL
-    logging.disable(logging.CRITICAL)
+    logging.disable(logging.ERROR)
 
 
 def enable_logging():
@@ -80,7 +80,6 @@ class EdgeInfo(object):
         self.x = x
         self.tracked = edge_data.get(x, False)
         self.alpha = 0.0
-        self.errors = 0
         self.startangle = None
         self.angle = None
         self.name = None
@@ -339,7 +338,11 @@ class EdgeInfo(object):
         return True  # two lines
 
     def arc_line_direction_lefthand(self, start_edge, line_edge, builder):
-        logger.debug("begin of arc_line_direction_lefthand")
+        logger.info("begin of arc_line_direction_lefthand")
+        if not self.is_arc():
+            logger.critical("FATAL: unexpected %s at position %s", self.classname(), self.n1)
+            sys.exit(1)
+
         assert(self.is_arc())
         assert(line_edge.is_line())
         start_edge.log_edge(":::: start")
@@ -389,13 +392,16 @@ class AreaBuilder(object):
                  rtol=1e-04,
                  atol=1e-04,
                  ndec=6):
+        assert(geom is not None)
         self.rtol = rtol
         self.atol = atol
         self.ndec = ndec
         self.geom = geom
         self.area_list = []
+        self.errors = 0
         self.journal = getJournal()
         self.nolog = nolog
+        self.num_edges = self.geom.number_of_edges()
 
     def __str__(self):
         return "rtol: {}\n".format(self.rtol) + \
@@ -410,7 +416,7 @@ class AreaBuilder(object):
 
     def append_new_area(self, area_list, elements):
         a = Area(elements, self.geom.center, 0.0)
-        a.type = 0  # air
+        a.set_type(TYPE_AIR)  # air
         area_list.append(a)
         return a
 
@@ -497,6 +503,7 @@ class AreaBuilder(object):
             logger.debug("<== %s", result['msg'])
             info_curr.set_all_tracked()
             result['ok'] = True
+            result['circle'] = True
             return result
 
         logger.debug("***** EDGE %s *****", 1)
@@ -521,9 +528,9 @@ class AreaBuilder(object):
         while not (nodes_are_equal(next_n1, start_n1) and
                    nodes_are_equal(next_n2, start_n2)):
             c += 1
-            if c > self.geom.num_edges * 2:
+            if c > self.num_edges * 2:
                 logger.error("FATAL: *** over %s elements in area ? ***",
-                             self.geom.num_edges)
+                             self.num_edges)
                 sys.exit(1)
 
             area.append(info_next.element)
@@ -619,7 +626,7 @@ class AreaBuilder(object):
         logger.debug("end of next_edge_lefthand_side")
         return nbr1
 
-    def create_inner_corner_auxiliary_areas(self):
+    def create_inner_corner_auxiliary_areas(self, startangle, endangle):
         logger.debug("begin of create_inner_corner_auxiliary_areas")
         if not self.geom.is_inner:
             logger.debug("end of create_inner_corner_auxiliary_areas: not inner")
@@ -627,8 +634,17 @@ class AreaBuilder(object):
 
         self.set_edge_attributes()
 
+        start_nodes = [n for n in self.geom.angle_nodes(
+            self.geom.center,
+            startangle, 1e-3, 1e-3)]
+        for n in start_nodes:
+            nbrs = self.geom.get_neighbors(n)
+            logger.debug("start node %s has %s neighbors", n, len(nbrs))
+        logger.debug("corner nodes: %s", self.geom.start_corners)
+        logger.debug("end nodes: %s", self.geom.end_corners)
         start_cp, start_exists = self.geom.get_start_airgap_corner()
         end_cp, end_exists = self.geom.get_end_airgap_corner()
+
         if start_exists and end_exists:
             logger.debug("end of create_inner_corner_auxiliary_areas: no aktion")
             return
@@ -667,8 +683,9 @@ class AreaBuilder(object):
                                            n,
                                            color='red',
                                            linestyle='dotted')
-                    self.geom.add_edge(cp, start_cp, start_line)
-                    result = self.get_new_area(start_cp, n)
+                    start_node = self.geom.get_node(start_cp)
+                    self.geom.add_edge(cp, start_node, start_line)
+                    result = self.get_new_area(start_node, n)
                     if result['ok']:
                         self.append_new_area(self.geom.area_list,
                                              result['area'])
@@ -698,8 +715,9 @@ class AreaBuilder(object):
                         self.geom.add_line(end_cp, n,
                                            color='red',
                                            linestyle='dotted')
-                    self.geom.add_edge(cp, end_cp, end_line)
-                    result = self.get_new_area(n, end_cp)
+                    end_node = self.geom.get_node(end_cp)
+                    self.geom.add_edge(cp, end_node, end_line)
+                    result = self.get_new_area(n, end_node)
                     if result['ok']:
                         self.append_new_area(self.geom.area_list,
                                              result['area'])
@@ -783,3 +801,112 @@ class AreaBuilder(object):
         logger.debug("end of get_inner_airgap_line #%s", len(nodes))
         return nodes, elements
 
+    def create_one_area_group(self, areas):
+        logger.debug("begin of create_one_area_group")
+        assert(len(self.area_list) == 0)
+
+        self.set_edge_attributes()
+        if not self.build_group_area(areas):
+            logger.warning("Creation of an areagroup failed")
+            return True
+        return False
+
+    def create_area_groups(self, list_of_areas):
+        logger.debug("begin of create_area_groups")
+        assert(len(self.area_list) == 0)
+
+        area_id_list = [a.id for a in list_of_areas]
+        timer = Timer(start_it=True)
+        #   ---
+        def delete_id(id):
+            try:
+                i = area_id_list.index(id)
+            except ValueError:
+                return True
+            area_id_list[i] = 0
+        #   ---
+
+        group_list = {}
+        for area in list_of_areas:
+            if not area.id in area_id_list:
+                continue
+
+            areas = [area]
+            delete_id(area.id)
+            for a in list_of_areas:
+                if area.id == a.id:
+                    continue
+                if not a.id in area_id_list:
+                    continue
+                if area.is_in_touch_with_area(self.geom, a):
+                    areas.append(a)
+                    delete_id(a.id)
+
+            group_list[area.id] = areas
+
+        group_keys = [int(x) for x in group_list.keys()]
+        logger.debug("=== Area Group List ===")
+        self.set_edge_attributes()
+        errors = 0
+        disable_logging()
+        for k in group_keys:
+            if not self.build_group_area(group_list[k]):
+                logger.warning("Creation of an areagroup failed")
+                errors += 1
+        enable_logging()
+
+        t = timer.stop("areagroups created in %0.4f seconds")
+        logger.debug("end of create_area_groups: %s groups created",
+                     len(self.area_list))
+        return errors > 0
+
+    def build_group_area(self, area_list):
+        id_list = [a.id for a in area_list]
+        logger.debug("Area Group: %s", id_list)
+
+        max_x = 0
+        area = None
+        for a in area_list:
+            if a.max_x > max_x:
+                max_x = a.max_x
+                area = a
+
+        x0, y0 = -9999.0, 0.0
+        for x, y in area.list_of_nodes():
+            if x > x0:
+                x0 = x
+                y0 = y
+
+        node0 = (x0, y0)
+        if not self.geom.g.has_node(node0):
+            node0 = self.geom.find_the_node(node0)
+            x0, y0 = node0
+
+        nbrs = self.geom.get_neighbors(node0)
+        logger.debug("Neighbors of %s", node0)
+
+        alpha0 = alpha_line(node0, (x, -9999.0))
+        angle0 = np.pi * 2.0
+        for n in nbrs:
+            logger.debug("** nbr: %s", n)
+            alpha1 = alpha_line(node0, n)
+            angle1 = alpha_angle(alpha1, alpha0)
+            logger.debug("** nbr=%s,  alpha=%s,  angle=%s", n, alpha1, angle1)
+            logger.debug("** if %s < %s then", angle1, angle0)
+            if angle1 < angle0:
+                node1 = n
+                angle0 = angle1
+
+        logger.debug("** Start with nodes %s ==> %s", node0, node1)
+        rslt = self.get_new_area(node0, node1)
+        if rslt['ok'] and rslt.get('circle', False):
+            rslt['ok'] = False
+            rslt['reverse'] = True
+
+        logger.debug("** Result: ok=%s, reverse=%s", rslt['ok'], rslt['reverse'])
+        if not rslt['ok'] and rslt['reverse']:
+            # new areagroup
+            a = self.append_new_area(self.area_list, rslt['area'])
+            a.areas_of_group = area_list
+            return True
+        return False

femagtools/dxfsl/conv.py

@@ -9,14 +9,18 @@ import os
 import io
 import femagtools
 from femagtools.dxfsl.converter import convert
+from femagtools.dxfsl.journal import Journal, getJournal
 import argparse
 import logging
 import logging.config
 
 logger = logging.getLogger(__name__)
+journal = None
 
 
 def main():
+    global journal
+
     argparser = argparse.ArgumentParser(
         description='Process DXF file and create a plot or FSL file.')
     argparser.add_argument('dxfile',
@@ -66,12 +70,12 @@ def main():
                            help='relative tolerance (pickdist)',
                            dest='rtol',
                            type=float,
-                           default=1e-03)
+                           default=1e-04)
     argparser.add_argument('--atol',
                            help='absolut tolerance (pickdist)',
                            dest='atol',
                            type=float,
-                           default=0.005)
+                           default=1e-03)
     argparser.add_argument('--da',
                            help='distance airgap',
                            dest='da',
@@ -90,6 +94,10 @@ def main():
                            help='show plots',
                            dest='show_plots',
                            action="store_true")
+    argparser.add_argument('--small',
+                           help='show rotor/stator plots only',
+                           dest='small_plots',
+                           action="store_true")
     argparser.add_argument('--areas',
                            help='show all areas',
                            dest='show_areas',
@@ -122,9 +130,9 @@ def main():
                            help='print information in logfile and set --debug',
                            dest='debug',
                            action="store_true")
-    argparser.add_argument('--logfile',
-                           help='print information in logfile',
-                           dest='logfile',
+    argparser.add_argument('-j',
+                           help='print information in journal file',
+                           dest='journal',
                            action="store_true")
     argparser.add_argument('--version',
                            help='show version of some packages',
@@ -134,6 +142,10 @@ def main():
                            help='print debug information in logfile',
                            dest='debugger',
                            action="store_true")
+    argparser.add_argument('--full_model',
+                           help='create full model (fsl only)',
+                           dest='full_model',
+                           action="store_true")
 
     args = argparser.parse_args()
 
@@ -141,7 +153,7 @@ def main():
     loglevel = logging.INFO
     if args.debug:
         loglevel = logging.DEBUG
-    if args.debug or args.logfile:
+    if args.debug:
         logfilename = 'debugger.log'
         print("see log-messages in {}".format(logfilename))
 
@@ -165,6 +177,8 @@ def main():
         logger.info("Python: %s", sys.version)
         sys.exit(0)
 
+    journal = getJournal(name='converter_journal', aktiv=args.journal)
+
     if args.airgap > 0.0:
         if args.airgap2 > 0.0:
             logger.info("Airgap is set from {} to {}"
@@ -218,17 +232,21 @@ def main():
                   view_korr=args.view_korr,
                   show_plots=args.show_plots,
                   show_areas=args.show_areas,
+                  small_plots=args.small_plots,
                   write_fsl=args.write_fsl,
                   write_png=args.write_png,
                   write_id=args.write_id,
-                  debug_mode=args.debugger)
-
+                  debug_mode=args.debugger,
+                  full_model=args.full_model)
+    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})
     if args.write_fsl:
         if res is not None:
             basename = os.path.basename(args.dxfile).split('.')[0]
             with io.open(basename + '.fsl', 'w', encoding='utf-8') as f:
                 f.write('\n'.join(res['fsl']))
-
+    journal.write_journal()
 
 if __name__ == "__main__":
     loglevel = logging.INFO