femagtools 1.8.3__py3-none-any.whl → 1.8.4__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- femagtools/__init__.py +1 -1
- femagtools/bch.py +10 -6
- femagtools/dxfsl/area.py +4 -1
- femagtools/dxfsl/conv.py +49 -17
- femagtools/dxfsl/converter.py +239 -75
- femagtools/dxfsl/fslrenderer.py +18 -22
- femagtools/dxfsl/functions.py +24 -2
- femagtools/dxfsl/geom.py +100 -23
- femagtools/dxfsl/machine.py +44 -7
- femagtools/dxfsl/shape.py +4 -0
- femagtools/dxfsl/symmetry.py +78 -25
- femagtools/fsl.py +0 -1
- femagtools/machine/afpm.py +2 -2
- femagtools/machine/effloss.py +2 -2
- femagtools/machine/im.py +6 -8
- femagtools/machine/sm.py +2 -2
- femagtools/mcv.py +10 -11
- femagtools/templates/mesh-airgap.mako +6 -0
- femagtools/utils.py +1 -1
- femagtools/windings.py +11 -4
- {femagtools-1.8.3.dist-info → femagtools-1.8.4.dist-info}/METADATA +1 -1
- {femagtools-1.8.3.dist-info → femagtools-1.8.4.dist-info}/RECORD +27 -27
- tests/test_parident.py +2 -1
- {femagtools-1.8.3.dist-info → femagtools-1.8.4.dist-info}/LICENSE +0 -0
- {femagtools-1.8.3.dist-info → femagtools-1.8.4.dist-info}/WHEEL +0 -0
- {femagtools-1.8.3.dist-info → femagtools-1.8.4.dist-info}/entry_points.txt +0 -0
- {femagtools-1.8.3.dist-info → femagtools-1.8.4.dist-info}/top_level.txt +0 -0
    
        femagtools/__init__.py
    CHANGED
    
    
    
        femagtools/bch.py
    CHANGED
    
    | @@ -307,14 +307,14 @@ class Reader: | |
| 307 307 | 
             
                            self.torque_fft = [
         | 
| 308 308 | 
             
                                {'order': order.tolist(),
         | 
| 309 309 | 
             
                                 'torque': tq.tolist()}]
         | 
| 310 | 
            -
                    except (KeyError, IndexError):
         | 
| 310 | 
            +
                    except (KeyError, IndexError, ValueError):
         | 
| 311 311 | 
             
                        pass
         | 
| 312 | 
            -
             | 
| 312 | 
            +
             | 
| 313 313 | 
             
                    # check number of phases
         | 
| 314 | 
            -
                    try: | 
| 314 | 
            +
                    try:
         | 
| 315 315 | 
             
                        if 'm' not in self.machine:
         | 
| 316 316 | 
             
                            self.machine['m'] = len(self.current_angles)
         | 
| 317 | 
            -
                    except: | 
| 317 | 
            +
                    except:
         | 
| 318 318 | 
             
                        pass
         | 
| 319 319 |  | 
| 320 320 | 
             
                    return self
         | 
| @@ -1439,17 +1439,21 @@ class Reader: | |
| 1439 1439 | 
             
                                            'psid', 'psiq', 'torque')
         | 
| 1440 1440 | 
             
                            except:
         | 
| 1441 1441 | 
             
                                pass
         | 
| 1442 | 
            -
                    if self.dqPar | 
| 1442 | 
            +
                    if self.dqPar.get('psim', 0):
         | 
| 1443 1443 | 
             
                        self.dqPar.pop('up', None)
         | 
| 1444 1444 | 
             
                    else:
         | 
| 1445 | 
            +
                        up = np.array(self.dqPar.pop('up', None))
         | 
| 1445 1446 | 
             
                        self.dqPar.pop('psim', None)
         | 
| 1447 | 
            +
             | 
| 1446 1448 | 
             
                    try:
         | 
| 1447 1449 | 
             
                        w1 = np.pi*self.dqPar['speed']*self.dqPar['npoles']
         | 
| 1448 1450 | 
             
                        r1 = self.machine.get('r1', 0.0)
         | 
| 1449 1451 | 
             
                        beta = np.array(self.dqPar['beta'])/180*np.pi
         | 
| 1450 1452 | 
             
                        iq = np.cos(beta)*self.dqPar['i1']
         | 
| 1451 1453 | 
             
                        id = np.sin(beta)*self.dqPar['i1']
         | 
| 1452 | 
            -
                         | 
| 1454 | 
            +
                        if 'psim' in self.dqPar:
         | 
| 1455 | 
            +
                            up = w1*np.array(self.dqPar['psim'])
         | 
| 1456 | 
            +
             | 
| 1453 1457 | 
             
                        ld = np.array(self.dqPar['ld'])
         | 
| 1454 1458 | 
             
                        lq = np.array(self.dqPar['lq'])
         | 
| 1455 1459 | 
             
                        uq = r1*iq + up + id*w1*ld
         | 
    
        femagtools/dxfsl/area.py
    CHANGED
    
    | @@ -641,7 +641,10 @@ class Area(object): | |
| 641 641 | 
             
                def get_alpha(self, center):
         | 
| 642 642 | 
             
                    if self.center_is_inside(center):
         | 
| 643 643 | 
             
                        return np.pi*2.0
         | 
| 644 | 
            -
                    return alpha_angle(self.min_angle, | 
| 644 | 
            +
                    return alpha_angle(self.min_angle,
         | 
| 645 | 
            +
                                       self.max_angle,
         | 
| 646 | 
            +
                                       rtol=0.0,
         | 
| 647 | 
            +
                                       atol=0.0)
         | 
| 645 648 |  | 
| 646 649 | 
             
                def get_mid_angle(self, center):
         | 
| 647 650 | 
             
                    if self.center_is_inside(center):
         | 
    
        femagtools/dxfsl/conv.py
    CHANGED
    
    | @@ -18,8 +18,18 @@ logger = logging.getLogger(__name__) | |
| 18 18 | 
             
            def main():
         | 
| 19 19 | 
             
                argparser = argparse.ArgumentParser(
         | 
| 20 20 | 
             
                    description='Process DXF file and create a plot or FSL file.')
         | 
| 21 | 
            +
                super_help = "--Help" in sys.argv
         | 
| 22 | 
            +
                if super_help:
         | 
| 23 | 
            +
                    sys.argv.append("--help")
         | 
| 24 | 
            +
             | 
| 21 25 | 
             
                argparser.add_argument('dxfile',
         | 
| 22 26 | 
             
                                       help='name of DXF file')
         | 
| 27 | 
            +
                argparser.add_argument('--Help',
         | 
| 28 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 29 | 
            +
                                             "show this extended help message and exit"),
         | 
| 30 | 
            +
                                       dest='Help',
         | 
| 31 | 
            +
                                       action="store_true",
         | 
| 32 | 
            +
                                       default=False)
         | 
| 23 33 | 
             
                argparser.add_argument('--PMSM',
         | 
| 24 34 | 
             
                                       help='Permanent Magnet Synchronous Motor',
         | 
| 25 35 | 
             
                                       dest='PMSM',
         | 
| @@ -47,47 +57,56 @@ def main(): | |
| 47 57 | 
             
                                       dest='stator',
         | 
| 48 58 | 
             
                                       default='')
         | 
| 49 59 | 
             
                argparser.add_argument('--sympart',
         | 
| 50 | 
            -
                                       help= | 
| 60 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 61 | 
            +
                                             'forced symmetry part'),
         | 
| 51 62 | 
             
                                       dest='sym_part',
         | 
| 52 63 | 
             
                                       type=int,
         | 
| 53 64 | 
             
                                       default=0)
         | 
| 54 65 | 
             
                argparser.add_argument('-a', '--airgap',
         | 
| 55 | 
            -
                                       help= | 
| 66 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 67 | 
            +
                                             'correct airgap'),
         | 
| 56 68 | 
             
                                       dest='airgap',
         | 
| 57 69 | 
             
                                       type=float,
         | 
| 58 70 | 
             
                                       default=0.0)
         | 
| 59 71 | 
             
                argparser.add_argument('--airgap2',
         | 
| 60 | 
            -
                                       help= | 
| 72 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 73 | 
            +
                                             'correct airgap'),
         | 
| 61 74 | 
             
                                       dest='airgap2',
         | 
| 62 75 | 
             
                                       type=float,
         | 
| 63 76 | 
             
                                       default=0.0)
         | 
| 64 77 | 
             
                argparser.add_argument('-t', '--symtol',
         | 
| 65 | 
            -
                                       help= | 
| 78 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 79 | 
            +
                                             'absolut tolerance to find symmetry axis'),
         | 
| 66 80 | 
             
                                       dest='sym_tolerance',
         | 
| 67 81 | 
             
                                       type=float,
         | 
| 68 82 | 
             
                                       default=0.001)
         | 
| 69 83 | 
             
                argparser.add_argument('--mindist',
         | 
| 70 | 
            -
                                       help= | 
| 84 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 85 | 
            +
                                             'minimal distance of spline control-points'),
         | 
| 71 86 | 
             
                                       dest='mindist',
         | 
| 72 87 | 
             
                                       type=float,
         | 
| 73 88 | 
             
                                       default=0.01)
         | 
| 74 89 | 
             
                argparser.add_argument('--rtol',
         | 
| 75 | 
            -
                                       help= | 
| 90 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 91 | 
            +
                                             'relative tolerance (pickdist)'),
         | 
| 76 92 | 
             
                                       dest='rtol',
         | 
| 77 93 | 
             
                                       type=float,
         | 
| 78 94 | 
             
                                       default=1e-04)
         | 
| 79 95 | 
             
                argparser.add_argument('--atol',
         | 
| 80 | 
            -
                                       help= | 
| 96 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 97 | 
            +
                                             'absolut tolerance (pickdist)'),
         | 
| 81 98 | 
             
                                       dest='atol',
         | 
| 82 99 | 
             
                                       type=float,
         | 
| 83 100 | 
             
                                       default=1e-03)
         | 
| 84 101 | 
             
                argparser.add_argument('--da',
         | 
| 85 | 
            -
                                       help= | 
| 102 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 103 | 
            +
                                             'distance airgap'),
         | 
| 86 104 | 
             
                                       dest='da',
         | 
| 87 105 | 
             
                                       type=float,
         | 
| 88 106 | 
             
                                       default=0.0)
         | 
| 89 107 | 
             
                argparser.add_argument('--dy',
         | 
| 90 | 
            -
                                       help= | 
| 108 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 109 | 
            +
                                             'distance yoke'),
         | 
| 91 110 | 
             
                                       dest='dy',
         | 
| 92 111 | 
             
                                       type=float,
         | 
| 93 112 | 
             
                                       default=0.0)
         | 
| @@ -104,11 +123,13 @@ def main(): | |
| 104 123 | 
             
                                       dest='small_plots',
         | 
| 105 124 | 
             
                                       action="store_true")
         | 
| 106 125 | 
             
                argparser.add_argument('--areas',
         | 
| 107 | 
            -
                                       help= | 
| 126 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 127 | 
            +
                                             'show all areas with single plots'),
         | 
| 108 128 | 
             
                                       dest='show_areas',
         | 
| 109 129 | 
             
                                       action="store_true")
         | 
| 110 130 | 
             
                argparser.add_argument('--id',
         | 
| 111 | 
            -
                                       help= | 
| 131 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 132 | 
            +
                                             'write id of areas into the plot'),
         | 
| 112 133 | 
             
                                       dest='write_id',
         | 
| 113 134 | 
             
                                       action="store_true")
         | 
| 114 135 | 
             
                argparser.add_argument('-f', '--fsl',
         | 
| @@ -116,7 +137,8 @@ def main(): | |
| 116 137 | 
             
                                       dest='write_fsl',
         | 
| 117 138 | 
             
                                       action="store_true")
         | 
| 118 139 | 
             
                argparser.add_argument('--fsl_single',
         | 
| 119 | 
            -
                                       help= | 
| 140 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 141 | 
            +
                                             'create separate fsl for rotor and stator'),
         | 
| 120 142 | 
             
                                       dest='write_fsl_single',
         | 
| 121 143 | 
             
                                       action="store_true")
         | 
| 122 144 | 
             
                argparser.add_argument('-v', '--view',
         | 
| @@ -124,11 +146,13 @@ def main(): | |
| 124 146 | 
             
                                       dest='view',
         | 
| 125 147 | 
             
                                       action="store_true")
         | 
| 126 148 | 
             
                argparser.add_argument('-k', '--korr',
         | 
| 127 | 
            -
                                       help= | 
| 149 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 150 | 
            +
                                             'show a view with korrections'),
         | 
| 128 151 | 
             
                                       dest='view_korr',
         | 
| 129 152 | 
             
                                       action="store_true")
         | 
| 130 153 | 
             
                argparser.add_argument('--png',
         | 
| 131 | 
            -
                                       help= | 
| 154 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 155 | 
            +
                                             'write plot in png-file only'),
         | 
| 132 156 | 
             
                                       dest='write_png',
         | 
| 133 157 | 
             
                                       action="store_true")
         | 
| 134 158 | 
             
                argparser.add_argument('-d', '--debug',
         | 
| @@ -139,8 +163,9 @@ def main(): | |
| 139 163 | 
             
                                       help='print information in logfile and set --debug',
         | 
| 140 164 | 
             
                                       dest='debug',
         | 
| 141 165 | 
             
                                       action="store_true")
         | 
| 142 | 
            -
                argparser.add_argument(' | 
| 143 | 
            -
                                       help= | 
| 166 | 
            +
                argparser.add_argument('--journal',
         | 
| 167 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 168 | 
            +
                                             'print information in journal file'),
         | 
| 144 169 | 
             
                                       dest='journal',
         | 
| 145 170 | 
             
                                       action="store_true")
         | 
| 146 171 | 
             
                argparser.add_argument('--version',
         | 
| @@ -155,6 +180,12 @@ def main(): | |
| 155 180 | 
             
                                       help='create full model (fsl only)',
         | 
| 156 181 | 
             
                                       dest='full_model',
         | 
| 157 182 | 
             
                                       action="store_true")
         | 
| 183 | 
            +
                argparser.add_argument('--no_processing',
         | 
| 184 | 
            +
                                       help=(argparse.SUPPRESS if not super_help else
         | 
| 185 | 
            +
                                             "omit multiprocessing"),
         | 
| 186 | 
            +
                                       dest='no_processing',
         | 
| 187 | 
            +
                                       action="store_true",
         | 
| 188 | 
            +
                                       default=False)
         | 
| 158 189 |  | 
| 159 190 | 
             
                args = argparser.parse_args()
         | 
| 160 191 |  | 
| @@ -251,7 +282,8 @@ def main(): | |
| 251 282 | 
             
                              write_id=args.write_id,
         | 
| 252 283 | 
             
                              debug_mode=args.debugger,
         | 
| 253 284 | 
             
                              full_model=args.full_model,
         | 
| 254 | 
            -
                              write_journal=args.journal | 
| 285 | 
            +
                              write_journal=args.journal,
         | 
| 286 | 
            +
                              no_processing=args.no_processing)
         | 
| 255 287 | 
             
                keys = ('tot_num_slot', 'num_sl_gen', 'num_poles', 'nodedist',
         | 
| 256 288 | 
             
                        'dy1', 'da1', 'da2', 'dy2', 'agndst', 'name')
         | 
| 257 289 | 
             
                logger.info("%s", {k: res[k] for k in keys if k in res})
         |