femagtools 1.7.8__py3-none-any.whl → 1.7.9__py3-none-any.whl

femagtools/__init__.py

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

femagtools/dxfsl/area.py

@@ -171,6 +171,38 @@ class Area(object):
                 if e1.n1 == e2.n1 and e1.n2 == e2.n2:
                     yield e1
 
+    def reduce_nodes(self, mindist=0.01):
+        """reduces number of nodes (lines only)
+        https://rdp.readthedocs.io/en/latest
+        """
+        import rdp
+        def reduce_nodes_(lines, mindist):
+            nodes = [le.get_nodes()[0] for le in lines]
+            r = rdp.rdp(nodes,
+                        epsilon=mindist)
+            if len(r) < len(nodes):
+                return [Line(Element(start=n1, end=n2))
+                        for n1, n2 in zip(r, r[1:])]
+            return lines
+
+        lines = []
+        reduced = []
+        for e in self.area:
+            if isinstance(e, Line):
+                lines.append(e)
+            else:
+                reduced.append(e)
+                reduced += reduce_nodes_(lines, mindist)
+                lines = []
+        if lines:
+            reduced += reduce_nodes_(lines, mindist)
+
+        if len(self.area) > len(reduced):
+            logger.info("reduced areas %d -> %d",
+                        len(self.area), len(reduced))
+            return reduced
+        return []
+
     def virtual_nodes(self, render=False, parts=64):
         if len(self.area) < 2:
             return
@@ -337,15 +369,9 @@ class Area(object):
         return False
 
     def minmax_dist_from_center(self, center):
-        rmin = 1e20
-        rmax = 0
-        for n in self.list_of_nodes():
-            r = np.linalg.norm(np.array(n)-center)
-            if r < rmin:
-                rmin = r
-            if r > rmax:
-                rmax = r
-        return rmin, rmax
+        nodes = np.array([n for e in self.area for n in e.get_nodes()])
+        return (np.min(np.linalg.norm(nodes-center, axis=1)),
+                np.max(np.linalg.norm(nodes-center, axis=1)))
 
     def minmax_angle_dist_from_center(self, center, dist):
         circ = Circle(Element(center=center, radius=dist))
@@ -959,11 +985,14 @@ class Area(object):
                                           self.legend())
 
     def remove_edges(self, g, ndec):
+        r = 0
         for e in self.area:
             try:
                 g.remove_edge(e.node1(ndec), e.node2(ndec))
+                r+=1
             except Exception:
                 continue
+        return r
 
     def is_circle(self):
         e = self.area[0]

femagtools/dxfsl/converter.py

@@ -533,6 +533,7 @@ def convert(dxfile,
                                                  EESM=EESM)
 
         if machine_outer.geom.is_stator() or machine_outer.has_windings():
+            machine_outer.geom.reduce_winding_nodes()
             machine_outer = build_machine_stator(machine_outer,
                                                  False,
                                                  mindist,
@@ -718,7 +719,7 @@ def convert(dxfile,
                                                p,
                                                EESM=EESM,
                                                single=True)
-
+                machine.geom.reduce_winding_nodes()
                 params = create_femag_parameters_stator(machine,
                                                         part[1])
             else:

femagtools/dxfsl/fslrenderer.py

@@ -162,6 +162,8 @@ class FslRenderer(object):
         geom.split_all_lines_longer_than(split_len)
         self.content = []
 
+        MAXDST=4.0
+        NUMLEVELS=10
         ndt_list = [(0.00, 1.1),
                     (0.05, 1.5),
                     (0.10, 1.7),
@@ -173,6 +175,9 @@ class FslRenderer(object):
                     (0.70, 4.5),
                     (0.85, 5.5),
                     (1.10, 5.5)]
+        ndt_list = [(1.1*nl/NUMLEVELS, nl/NUMLEVELS*(MAXDST-1.1)+1.1)
+                    for nl in range(NUMLEVELS+1)]
+
         dist = geom.max_radius - geom.min_radius
         el_sorted = self.sorted_elements(geom, inner)
 
@@ -182,7 +187,7 @@ class FslRenderer(object):
             if ndt_list[n][0] < d_percent:
                 self.agndst = ndt_list[n][1] * self.agndst
                 self.content.append('\nndt({}*agndst)\n'.
-                                    format(ndt_list[n][1]))
+                                    format(round(ndt_list[n][1], 1)))
                 while ndt_list[n][0] < d_percent:
                     n += 1
             e.render(self)
@@ -233,6 +238,8 @@ class FslRenderer(object):
                 'r, phi = c2pr(x0, y0)',
                 'x1, y1 = pr2c(r1, phi)',
                 'x2, y2 = pr2c(r1, {}*math.pi/parts)'.format(slice),
+                f'-- end max corner {geom.end_corners[-1]}',
+                f'-- center {geom.center}',
                 f'r = {geom.dist_end_max_corner()}',
                 'x3, y3 = pr2c(r, {}*math.pi/parts)'.format(slice),
                 'nc_line(x0, y0, x1, y1, 0)',

femagtools/dxfsl/geom.py

@@ -91,11 +91,12 @@ def create_geometry(new_elements, split=False):
 
 
 def intersect_and_split(inp_elements, rtol, atol):
-    logger.info("Load input elements ... ")
+    logger.info("Load input elements ... %s", len(inp_elements))
     out_elements = []
     for e in inp_elements:
         out_size = len(out_elements)
         intersect_and_split_element(e, out_elements, 0, out_size, rtol, atol)
+    logger.debug(" done", e)
     return out_elements
 
 
@@ -650,9 +651,9 @@ class Geometry(object):
             return True
         return False
 
-    def get_edge(self, eg):
+    def get_edge(self, obj):
         return [[e[0], e[1], e[2]['object']] for e in self.g.edges(data=True)
-                if e[2]['object'] is eg]
+                if e[2]['object'] is obj]
 
     def get_edge_element(self, n1, n2):
         e_dict = self.g.get_edge_data(n1, n2)
@@ -679,9 +680,9 @@ class Geometry(object):
         assert(len(e) == 1)
         self._remove_edge(e[0][0], e[0][1])
 
-    def remove_edges(self, edges):
-        for e in edges:
-            self.remove_edge(e)
+    def remove_edges(self, objs):
+        for o in objs:
+            self.remove_edge(o)
 
     def _remove_node(self, n):
         for nbr in self.g.neighbors(n):
@@ -867,8 +868,8 @@ class Geometry(object):
         logger.debug("begin of dist_end_max_corner")
         logger.debug("end corners: %s", self.end_corners)
 
-        if self.is_mirrored():
-            return self.dist_start_max_corner()
+        #if self.is_mirrored():
+        #    return self.dist_start_max_corner()
         d = distance(self.center, self.end_corners[-1])
         logger.debug("end of dist_end_max_corner: %s", d)
         return d
@@ -1843,6 +1844,16 @@ class Geometry(object):
             return [h for (k, h) in legend.items()]
         return []
 
+    def reduce_winding_nodes(self, mindist=0.01):
+        for area in self.list_of_areas():
+            if area.is_winding():
+                reduced_shapes = area.reduce_nodes(mindist)
+                if reduced_shapes:
+                    area.remove_edges(self.g, ndec)
+                    area.area = reduced_shapes
+                    for r in reduced_shapes:
+                        self.add_element(r, rtol=self.rtol, atol=self.atol)
+
     def render_areagroups(self, renderer):
         if not self.areagroup_list:
             return

femagtools/dxfsl/svgparser.py

@@ -37,10 +37,17 @@ def get_angles(sweep, center, p1, p2):
 def get_shapes(path):
     """return list of node elements (A, L)"""
     state = ''
+    prevstate = ''
     p = []
-    for s in [s for s in re.split('([AML])|,|\\s+',path) if s]:
+    for s in [s for s in re.split('([AMLHV])|,|\\s+', path) if s]:
         if state == '':
-            state = s[0]
+            s = s.upper()
+            if s in ('A','M','L','H','V'):
+                state = s
+                prevstate = s
+            else:  # wild guess
+                p.append(float(s))
+                state = prevstate
         elif state == 'M':
             p.append(float(s))
             if len(p) == 2:
@@ -52,7 +59,7 @@ def get_shapes(path):
             if len(p) == 2:
                 p2 = np.array(p)
                 logger.debug("Line %s -> %s",
-                            p1, p2)
+                             p1, p2)
                 yield Line(Element(start=p1, end=p2))
                 p1 = p2.copy()
                 p = []
@@ -66,7 +73,7 @@ def get_shapes(path):
                 center = get_center(r, p1, p2, sweep)
                 start, end = get_angles(sweep, center, p1, p2)
                 logger.debug("Arc center %s r %f %f -> %f",
-                            center, r, start, end)
+                             center, r, start, end)
                 yield Arc(Element(center=center,
                                   radius=r,
                                   start_angle=start*180/np.pi,
@@ -74,14 +81,34 @@ def get_shapes(path):
                 p1 = p2.copy()
                 p = []
                 state = ''
+        elif state == 'H':
+            logger.debug("h %s", s)
+            p2 = np.array((float(s), 0))
+            yield Line(Element(start=p1, end=p2))
+            p1 = p2.copy()
+            p = []
+            state = ''
+        elif state == 'V':
+            logger.debug("V %s", s)
+            p2 = np.array((0, float(s)))
+            yield Line(Element(start=p1, end=p2))
+            p1 = p2.copy()
+            p = []
+            state = ''
         else:
             raise ValueError(f"unsupported path {state}")
 
 
 def svgshapes(svgfile):
     svg = ET.parse(svgfile)
+    bcolor = re.compile('fill:([^;]+)')
+    sr = 0
     for p in svg.findall(".//{http://www.w3.org/2000/svg}path"):
+        m = bcolor.search(p.get('style'))
+        if m:
+            logger.info("subregion %d: %s", sr, m.groups()[0])
         yield from get_shapes(p.get('d'))
+        sr += 1
     for p in svg.findall(".//{http://www.w3.org/2000/svg}line"):
         yield Line(Element(start=[float(p.get('x1')), float(p.get('y1'))],
                            end=[float(p.get('x2')), float(p.get('y2'))]))

femagtools/femag.py

@@ -401,6 +401,10 @@ class BaseFemag(object):
                 ttemp = list(zip(*temp))
                 return {'t': ttemp[0], 'temperature': ttemp[1]}
 
+            if simulation['calculationMode'] == 'hsn':
+                model = self.read_nc()
+                return model.get_minmax_temp()
+
             if not bch:
                 bch = self.read_bch(self.modelname)
             if simulation['calculationMode'] == 'pm_sym_fast' or \
@@ -468,6 +472,11 @@ class BaseFemag(object):
                     bch.magnet_loss_th = m.th_loss
                 except:
                     pass
+            try: 
+                if hasattr(self, 'dy2'): 
+                    setattr(bch, 'dy2', self.dy2)
+            except: 
+                pass 
             return bch
 
 
@@ -599,6 +608,11 @@ class Femag(BaseFemag):
             stateofproblem = 'mag_static'
 
         self.run(fslfile, options, fsl_args, stateofproblem=stateofproblem)
+        
+        try: 
+            setattr(self, "dy2", machine['stator']['dy2'])
+        except: 
+            pass
         if simulation:
             return self.readResult(simulation)
 

femagtools/fsl.py

@@ -356,25 +356,18 @@ class Builder:
             if 'thcond' in model.stator:
                 fslcmds += [
                     '-- thermal properties in airgap',
-                    'if m.zeroangl ~= nil then',
-                    '   ag_cond = 0.063',
-                    '   thcap = 1007',
-                    '   beta = math.pi*m.npols_gen/m.num_poles + m.zeroangl/180*math.pi',
-                    '   xai, yai = pr2c((da1+da2)/4, beta)',
-                    '   def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
-                    '   xai, yai = pr2c((da1+da2)/4-ag/4, beta)',
-                    '   def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
-                    '   xai, yai = pr2c((da1+da2)/4+ag/4, beta)',
-                    '   def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
-                    '',
-                    '   state_of_problem("therm_static") -- thermic boundary conditions',
-                    '   x1,y1 = pd2c(dy2/2,m.zeroangl)',
-                    '   x2,y2 = pd2c(dy1/2,m.zeroangl)',
-                    '   beta = 360*m.npols_gen/m.num_poles',
-                    '   x3,y3 = pd2c(dy1/2,beta+m.zeroangl)',
-                    '   x4,y4 = pd2c(dy2/2,beta+m.zeroangl)',
-                    '   def_bcond_tp(x1,y1,x2,y2,x3,y3,x4,y4, 4)',
+                    'if m.zeroangl == nil then',
+                    '   m.zeroangl = 0.0',
                     'end',
+                    'beta = math.pi*m.npols_gen/m.num_poles + m.zeroangl/180*math.pi',
+                    '',
+                    'state_of_problem("therm_static") -- thermic boundary conditions',
+                    'x1,y1 = pd2c(dy2/2,m.zeroangl)',
+                    'x2,y2 = pd2c(dy1/2,m.zeroangl)',
+                    'beta = 360*m.npols_gen/m.num_poles',
+                    'x3,y3 = pd2c(dy1/2,beta+m.zeroangl)',
+                    'x4,y4 = pd2c(dy2/2,beta+m.zeroangl)',
+                    'def_bcond_tp(x1,y1,x2,y2,x3,y3,x4,y4, 4)',
                     'state_of_problem("mag_static")']
             return fslcmds
         return []
@@ -440,14 +433,14 @@ class Builder:
         return []
 
     def create_gen_winding(self, model):
-        try:
-            if model.winding['wire']['name'] == 'hairpin_winding':
-                model.winding['wire'].update(
-                    {"num_layers": model.winding["num_layers"]})
-                genwdg = self.__render(model.winding,
-                                       'gen_' + model.winding['wire'].get('name'))
-        except KeyError:  # not hairpin_winding
+        try: 
+            model.winding['wire'].update(
+                {"num_layers": model.winding["num_layers"]})
+            genwdg = self.__render(model.winding,
+                                    'gen_' + model.winding['wire'].get('name'))
+        except: 
             genwdg = self.__render(model, 'gen_winding')
+
         k = list({'leak_dist_wind',
                   'leak_evol_wind',
                   'leak_tooth_wind'}.intersection(model.winding))
@@ -510,6 +503,9 @@ class Builder:
             setattr(model, 'stator', {})
         model.stator['num_slots'] = conv.get('tot_num_slot')
         model.stator['slot_area'] = conv.get('slot_area')
+        model.stator['dy1'] = conv.get('dy1')*1e-3
+        model.stator['dy2'] = conv.get('dy2')*1e-3
+
         if model.get('num_agnodes', 0) == 0:
             model.set_value('agndst', conv['agndst']*1e-3)
             logger.info("num poles %d num slots %d outer diameter %.4f m agndst %.4f mm",
@@ -526,19 +522,39 @@ class Builder:
 
         if 'fsl_stator' in conv:
             self.fsl_stator = True
-            model.stator['dxf'] = dict(fsl=conv['fsl_stator'])
+            th_props = [' ']
+            if model.stator.get('thcond', 0):
+                th_props = [f'stator_density = {1e3*model.stator["density"]}',
+                            f'stator_thcond = {model.stator["thcond"]}',
+                            f'stator_thcap = {model.stator["thcap"]}',
+                            ]
+            model.stator['dxf'] = dict(fsl=conv['fsl_stator'] + th_props)
         if not (hasattr(model, 'magnet') or hasattr(model, 'rotor')):
             if params['EESM']:
                 setattr(model, 'rotor', {})
             else:
                 setattr(model, 'magnet', {})
+
         if 'fsl_rotor' in conv:
             self.fsl_rotor = True
+            th_props = ['']
             if hasattr(model, 'magnet'):
-                model.magnet['dxf'] = dict(fsl=conv['fsl_rotor'])
+                if model['magnet'].get('thcond', 0):
+                    logger.info(model['magnet'])
+                    th_props = [f'rotor_density = {1e3*model["magnet"]["density"]}',
+                                f'rotor_thcond = {model["magnet"]["thcond"]}',
+                                f'rotor_thcap = {model["magnet"]["thcap"]}'
+                                ]
+                model.magnet['dxf'] = dict(fsl=conv['fsl_rotor'] + th_props)
             if hasattr(model, 'rotor'):
                 model.rotor['dxf'] = dict(fsl=conv['fsl_rotor'])
 
+    def create_thermal_properties(self, model):
+        if model.stator.get('thcond') and model.stator.get('thcap') and \
+            model.stator.get('density'):
+            return self.__render(model, 'prepare_thermal')
+        return ['']
+
     def create_model(self, model, magnets=[], condMat=[], ignore_material=False):
         magnetMat = {}
         material = ''
@@ -594,6 +610,35 @@ class Builder:
                          self.create_magnet_model(model))
                 if magnetMat:
                     rotor += self.create_magnet(model, magnetMat)
+
+                if model['magnet'].get('thcond_magnet', 0):
+                    th_props = [f'magn_density = {1e3*model["magnet"]["spmaweight_magnet"]}',
+                                f'magn_thcond = {model["magnet"]["thcond_magnet"]}',
+                                f'magn_thcap = {model["magnet"]["thcap_magnet"]}'
+                                ]
+                    rotor += th_props
+                    if model.is_dxffile() or 'dxf' in model['magnet']:
+                        rotor += ['if x0_shaft == 0.0 then',
+                                  '-- add air layer (inside) for heat transfer',
+                                  '   h = dy2/2/3',
+                                  '   if h > 5 then',
+                                  '      h = 3.8',
+                                  '   end ',
+                                  '   if m.zeroangl == nil then ',
+                                  '      m.zeroangl = 0.0',
+                                  '   end',
+                                  '   beta = 360*m.npols_gen/m.num_poles',
+                                  '   x0, y0 = pd2c(dy2/2, m.zeroangl)',
+                                  '   x1, y1 = pd2c(dy2/2-h, m.zeroangl)',
+                                  '   x2, y2 = pd2c(dy2/2-h, beta+m.zeroangl)',
+                                  '   x3, y3 = pd2c(dy2/2, beta+m.zeroangl)',
+                                  '   nc_line(x0, y0, x1, y1, 0)',
+                                  '   nc_circle(x1, y1, x2, y2, 0)',
+                                  '   nc_line(x2, y2, x3, y3, 0)',
+                                  '   x0, y0 = pd2c(dy2/2-h/2, beta/2+m.zeroangl)',
+                                  '   create_mesh_se(x0, y0)',
+                                'end'
+                                 ]
             else:
                 rotor = self.create_rotor_model(
                     model, condMat, ignore_material)
@@ -635,7 +680,8 @@ class Builder:
                     rotor +
                     self.mesh_airgap(model) +
                     self.create_connect_models(model) +
-                    self.create_rotor_winding(model))
+                    self.create_rotor_winding(model)) + \
+                    self.create_thermal_properties(model)
 
         return (self.open_model(model) +
                 self.create_fe_losses(model) +

femagtools/isa7.py

@@ -544,6 +544,10 @@ class Isa7(object):
              16: [0.8274509803921568, 0.8274509803921568, 0.8274509803921568]} # LIGHGREY
 
     def __init__(self, reader):
+        try:
+            self.state_of_problem = reader.state_of_problem
+        except:
+            pass
         self.points = [Point(x, y)
                        for x, y in zip(reader.POINT_ISA_POINT_REC_PT_CO_X,
                                        reader.POINT_ISA_POINT_REC_PT_CO_Y)]
@@ -1139,6 +1143,43 @@ class Isa7(object):
                 sreg[sr.name] = [0,0,0]
         return sreg
 
+    def get_minmax_temp(self):
+        def node_subregion(subregion_name):
+            node_temperature = []
+            for i in self.subregions:
+                if i.name.lower() == subregion_name:
+                    for j in i.elements():
+                        for k in j.vertices:
+                            node_temperature.append(k.vpot[-1])
+            ndtemp = np.unique(node_temperature)
+            return [np.amax(ndtemp), np.amin(ndtemp), np.mean(ndtemp)]
+
+        zero_temp = [0.0, 0.0, 0.0]
+        component_temperature = dict(styoke=zero_temp, stteeth=zero_temp,
+                                     magnet=zero_temp, winding=zero_temp)
+        for i in self.subregions:
+            if i.name:
+                sreg_name = i.name.lower()
+                if sreg_name in ('stza', 'stth', 'stteeth'):
+                    component_temperature['stteeth'] = node_subregion(sreg_name)
+                elif sreg_name in ('styk', 'styoke', 'stjo'):
+                    component_temperature['styoke'] = node_subregion(sreg_name)
+                elif sreg_name == 'iron':
+                    component_temperature['iron'] = node_subregion(sreg_name)
+                elif sreg_name == 'pmag':
+                    component_temperature['magnet'] = node_subregion(sreg_name)
+                else:
+                    pass
+
+        wdg_temps = []
+        for j in self.wdg_elements():
+            for k in j.vertices:
+                wdg_temps.append(k.vpot[-1])
+        wdg_temp = np.unique(wdg_temps)
+        component_temperature['winding'] = [np.amax(wdg_temp),
+                                            np.amin(wdg_temp),
+                                            np.mean(wdg_temp)]
+        return component_temperature
 
     def flux_dens(self, x, y, icur, ibeta):
         el = self.get_element(x, y)

femagtools/job.py

@@ -112,7 +112,7 @@ class Task(object):
         if bchfile_list:
             result = femagtools.bch.Reader()
             with open(bchfile_list[-1]) as f:
-                logger.info("Reading %s",
+                logger.debug("Reading %s",
                             bchfile_list[-1])
                 result.read(f)
             if bagdat.exists():
@@ -127,7 +127,7 @@ class Task(object):
             asm_list = sorted(basedir.glob(
                 '*_[0-9][0-9][0-9].ASM'))
             if asm_list:
-                logger.info("Reading %s",
+                logger.debug("Reading %s",
                             asm_list[-1])
                 result = femagtools.asm.read(asm_list[-1])
                 if bagdat.exists():

femagtools/machine/afpm.py

@@ -645,6 +645,9 @@ class AFPM:
                 parameters={
                     'phi_voltage_winding': current_angles})
             logger.info("Current angles: %s", current_angles)
+        elif (simulation['calculationMode'] == 'cogg_calc' and
+            'poc' not in simulation):
+            simulation['poc'] = poc.Poc(machine['pole_width'])
 
         lresults = self.parstudy(
             parvardef,
@@ -652,5 +655,6 @@ class AFPM:
             simulation, engine)  # Note: imcomplete machine prevents rebuild
 
         results = process(lfe, pole_width, machine, lresults['f'])
-        results.update(_psidq_ldq(results, nlresults))
+        if nlresults:
+            results.update(_psidq_ldq(results, nlresults))
         return results

femagtools/machine/utils.py

@@ -411,6 +411,7 @@ def dqparident(workdir, engine, temp, machine,
         elif ('wire_width' in machine[wdgk]) and ('wire_height' in machine[wdgk]):
             aw = machine[wdgk]['wire_width']*machine[wdgk]['wire_height']
         else:  # wire diameter from slot area
+            da1 = machine['bore_diam']
             aw = 0.75 * fcu * np.pi*da1*hs/Q1/wdg.l/N
         r1 = wdg_resistance(wdg, N, g, aw, da1, hs, lfe)
     except (NameError, KeyError):
@@ -489,6 +490,8 @@ def dqparident(workdir, engine, temp, machine,
         machine['poles'] = 2*results['f'][0]['machine']['p']
         da1 = 2*results['f'][0]['machine']['fc_radius']
         wdg = create_wdg(machine)
+    if 'bore_diam' in machine:
+        da1 = machine['bore_diam']
     ls1 = 0
     try:
         leakages = [float(x)
@@ -569,14 +572,12 @@ def dqparident(workdir, engine, temp, machine,
         if r1:
             dqpars['r1'] = r1
         else:
-            from .. import nc
-            model = nc.read(str(pathlib.Path(workdir) / machine['name']))
+            model = parvar.femag.read_nc()
             try:
                 nlayers = wdg.l
             except UnboundLocalError:
                 wdg = create_wdg(machine)
                 nlayers = wdg.l
-                da1 = machine['outer_diam']
             Q1 = wdg.Q
             istat = 0 if model.get_areas()[0]['slots'] else 1
             asl = model.get_areas()[istat]['slots']

femagtools/model.py

@@ -386,6 +386,13 @@ class MachineModel(Model):
                 if mcv:
                     logger.debug('shaft mcv %s', mcv)
                     rotor['mcvkey_shaft'] = magcurves.fix_name(mcv)
+                    mshaft = magcurves.find_by_name(mcv)
+                    thkeys_shaft = ['thcond', 'thcap', 'rho']
+                    if mshaft and set(thkeys_shaft).issubset(mshaft.keys()):
+                        for k in thkeys_shaft:
+                            rotor[k+'_shaft'] = mshaft[k]
+                        rotor['spmaweight_shaft'] = rotor['rho_shaft']
+                    
                     self.stator['mcvkey_shaft_name'] = mcv
                     names.append((mcv, 1.0))
                 else:

femagtools/moo/population.py

@@ -198,21 +198,23 @@ class Population:
         self.update_pareto_information()
         retval = [[] for s in range(max(self.pareto_rank)+1)]
         for i, j in enumerate(self.individuals):
-            retval[self.pareto_rank[i]].append(i)
+            retval[self.pareto_rank[i]].append(j)
         return retval
 
     def compute_ideal(self):
-        return [min(x)
+        return [np.min(np.array(x)[np.isfinite(x)])
                 for x in zip(*[i.cur_f
-                               for i in self.individuals if i.rank == 0])]
+                               for i in self.individuals
+                               if i.rank == 0])]
 
     def compute_nadir(self):
-        return [max(x)
+        return [np.max(np.array(x)[np.isfinite(x)])
                 for x in zip(*[i.cur_f
-                               for i in self.individuals if i.rank == 0])]
+                               for i in self.individuals
+                               if i.rank == 0])]
 
     def compute_worst(self):
-        return [max(x)
+        return [np.max(np.array(x)[np.isfinite(x)])
                 for x in zip(*[i.cur_f
                                for i in self.individuals])]
 
@@ -252,7 +254,7 @@ class Population:
             raise ValueError(
                 'Invalid components of the objective function selected for plot')
 
-        p_dim = self.problem.f_dimension
+        p_dim = self.problem.f_dim
 
         if p_dim == 1:
             raise ValueError(