fiqus 2024.7.0__py3-none-any.whl → 2024.12.1__py3-none-any.whl

fiqus/parsers/ParserRES.py

@@ -1,143 +1,143 @@
-import pandas as pd
-import re
-from collections import defaultdict
-
-class ParserRES:
-
-    def __init__(self, res_file_path, write_data=None):
-        """
-        TO BE DONE!!
-        Read res file and returns its content as object attribute .pqv (postprocessed quantity value) that is a float
-        :param dat_file_path: Full path to .pos file, including file name and extension.
-        :return: nothing, keeps attribute pqv (postprocessed quantity value)
-        """
-        self._res_format_markers = {'s': '$ResFormat', 'e': '$EndResFormat'}
-        self._getdp_version_markers = {'s': '/* ', 'e': ','}
-        self._encoding_markers = {'s': ', ', 'e': ' */'}
-        # the 1.1 is hard-coded according to the GetDP documentation, 
-        # see https://getdp.info/doc/texinfo/getdp.html#File-formats
-        self._res_file_format = {'s': '1.1 ', 'e': '\n$EndResFormat'}
-
-        self.solution = defaultdict(dict)
-        
-        if write_data:
-            self._res_file_path = res_file_path
-            self._write_data = write_data
-            self._write_res_file()
-        else:
-            # read contents of .res file
-            with open(res_file_path) as f:
-                self._contents = f.read()
-            self._parse_res_file()
-
-
-    def __get_content_between_markers(self, markers_dict):
-            """
-            Gets text string between two markers specified in markers_dict
-            """
-            return self._contents[self._contents.find(markers_dict['s']) + len(markers_dict['s']):self._contents.find(markers_dict['e'])]
-
-    def _res_header(self):
-        """
-        Parse the header of the .res file.
-        Add the attributes: 
-        - getdp_version: GetDP version that created the .res file
-        - encoding: encoding of the .res file
-        - res_file_format: format of the .res file
-        """
-        self.getdp_version = self.__get_content_between_markers(self._getdp_version_markers)
-        self.encoding = self.__get_content_between_markers(self._encoding_markers)
-        self.res_file_format = self.__get_content_between_markers(self._res_file_format)
-
-    def _get_all_solution_blocks(self):
-        """
-        Add all unparsed solution blocks to the attribute _solution_blocks
-        using regular expressions. It is a list of lists which each sub-list 
-        containing exactly one solution block.
-        """
-        solution_string = self._contents[self._contents.find('$Solution'):]
-        self._solution_blocks = re.findall(r'\$Solution.*?\$EndSolution', solution_string, re.DOTALL)
-
-    def _parse_res_file_single_solution_block(self, solution_block_split_by_line):
-
-        # the first line is ignored 
-        header = solution_block_split_by_line[1]
-        header_split = header.split()
-        dof_data = int(header_split[0])
-        time_real = float(header_split[1])
-        time_imag = float(header_split[2])
-        time_step = int(header_split[3])
-        solution = [float(entry) for entry in solution_block_split_by_line[2:-1]]
-
-        if "time_real" not in self.solution: 
-            self.solution['time_real'] = [time_real]
-        else: 
-            self.solution['time_real'].append(time_real)
-
-        if "time_imag" not in self.solution: 
-            self.solution['time_imag'] = [time_imag]
-        else: 
-            self.solution['time_imag'].append(time_imag)
-
-        if "time_step" not in self.solution: 
-            self.solution['time_step'] = [time_step]
-        else: 
-            self.solution['time_step'].append(time_step)
-
-        if "dof_data" not in self.solution: 
-            self.solution['dof_data'] = [dof_data]
-        else: 
-            self.solution['dof_data'].append(dof_data)
-
-        if "solution" not in self.solution: 
-            self.solution['solution'] = [solution]
-        else: 
-            self.solution['solution'].append(solution)
-
-    @staticmethod
-    def __get_lines(data_str):
-        """
-        Converts text string into a list of lines
-        """
-        data_str = re.sub('\n', "'", data_str)
-        data_str = re.sub('"', '', data_str)
-        str_list = re.split("'", data_str)
-        return str_list
-
-    def _parse_res_file_solution_blocks(self):
-        """
-        
-        """
-        for solution_block in self._solution_blocks:
-            # split by line
-            solution_block_split_by_line = self.__get_lines(solution_block)
-            self._parse_res_file_single_solution_block(solution_block_split_by_line)
-
-    def _parse_res_file(self): 
-        self._res_header()
-        self._get_all_solution_blocks()
-        self._parse_res_file_solution_blocks()
-
-    def _write_res_file(self):
-        with open(self._res_file_path, "w") as f:
-            # write header
-            f.write(f"$ResFormat /* {self._write_data.getdp_version}, {self._write_data.encoding} */\n")
-            # write res file format
-            f.write(f"1.1 {self._write_data.res_file_format}\n")
-            f.write(f"$EndResFormat\n")
-
-            self._write_solution_block(f)
-
-    def _write_solution_block(self, f):
-        for time_real, time_imag, time_step, dof_data, solution in zip(self._write_data.solution['time_real'], self._write_data.solution['time_imag'], self._write_data.solution['time_step'], self._write_data.solution['dof_data'], self._write_data.solution['solution']):
-        
-            f.write(f"$Solution  /* DofData #{dof_data} */\n")
-            f.write(f"{dof_data} {time_real:.16g} {time_imag:.16g} {time_step}\n")
-            f.write('\n'.join('{0:.16g}'.format(sol_entry) for sol_entry in solution))
-            f.write(f"\n$EndSolution\n")
-
-# ==============================================================================
-#parsedRes = ParserRES('test.res')
-#ParserRES('test_written.res', write_data=parsedRes)
-#import filecmp 
+import pandas as pd
+import re
+from collections import defaultdict
+
+class ParserRES:
+
+    def __init__(self, res_file_path, write_data=None):
+        """
+        TO BE DONE!!
+        Read res file and returns its content as object attribute .pqv (postprocessed quantity value) that is a float
+        :param dat_file_path: Full path to .pos file, including file name and extension.
+        :return: nothing, keeps attribute pqv (postprocessed quantity value)
+        """
+        self._res_format_markers = {'s': '$ResFormat', 'e': '$EndResFormat'}
+        self._getdp_version_markers = {'s': '/* ', 'e': ','}
+        self._encoding_markers = {'s': ', ', 'e': ' */'}
+        # the 1.1 is hard-coded according to the GetDP documentation, 
+        # see https://getdp.info/doc/texinfo/getdp.html#File-formats
+        self._res_file_format = {'s': '1.1 ', 'e': '\n$EndResFormat'}
+
+        self.solution = defaultdict(dict)
+        
+        if write_data:
+            self._res_file_path = res_file_path
+            self._write_data = write_data
+            self._write_res_file()
+        else:
+            # read contents of .res file
+            with open(res_file_path) as f:
+                self._contents = f.read()
+            self._parse_res_file()
+
+
+    def __get_content_between_markers(self, markers_dict):
+            """
+            Gets text string between two markers specified in markers_dict
+            """
+            return self._contents[self._contents.find(markers_dict['s']) + len(markers_dict['s']):self._contents.find(markers_dict['e'])]
+
+    def _res_header(self):
+        """
+        Parse the header of the .res file.
+        Add the attributes: 
+        - getdp_version: GetDP version that created the .res file
+        - encoding: encoding of the .res file
+        - res_file_format: format of the .res file
+        """
+        self.getdp_version = self.__get_content_between_markers(self._getdp_version_markers)
+        self.encoding = self.__get_content_between_markers(self._encoding_markers)
+        self.res_file_format = self.__get_content_between_markers(self._res_file_format)
+
+    def _get_all_solution_blocks(self):
+        """
+        Add all unparsed solution blocks to the attribute _solution_blocks
+        using regular expressions. It is a list of lists which each sub-list 
+        containing exactly one solution block.
+        """
+        solution_string = self._contents[self._contents.find('$Solution'):]
+        self._solution_blocks = re.findall(r'\$Solution.*?\$EndSolution', solution_string, re.DOTALL)
+
+    def _parse_res_file_single_solution_block(self, solution_block_split_by_line):
+
+        # the first line is ignored 
+        header = solution_block_split_by_line[1]
+        header_split = header.split()
+        dof_data = int(header_split[0])
+        time_real = float(header_split[1])
+        time_imag = float(header_split[2])
+        time_step = int(header_split[3])
+        solution = [float(entry) for entry in solution_block_split_by_line[2:-1]]
+
+        if "time_real" not in self.solution: 
+            self.solution['time_real'] = [time_real]
+        else: 
+            self.solution['time_real'].append(time_real)
+
+        if "time_imag" not in self.solution: 
+            self.solution['time_imag'] = [time_imag]
+        else: 
+            self.solution['time_imag'].append(time_imag)
+
+        if "time_step" not in self.solution: 
+            self.solution['time_step'] = [time_step]
+        else: 
+            self.solution['time_step'].append(time_step)
+
+        if "dof_data" not in self.solution: 
+            self.solution['dof_data'] = [dof_data]
+        else: 
+            self.solution['dof_data'].append(dof_data)
+
+        if "solution" not in self.solution: 
+            self.solution['solution'] = [solution]
+        else: 
+            self.solution['solution'].append(solution)
+
+    @staticmethod
+    def __get_lines(data_str):
+        """
+        Converts text string into a list of lines
+        """
+        data_str = re.sub('\n', "'", data_str)
+        data_str = re.sub('"', '', data_str)
+        str_list = re.split("'", data_str)
+        return str_list
+
+    def _parse_res_file_solution_blocks(self):
+        """
+        
+        """
+        for solution_block in self._solution_blocks:
+            # split by line
+            solution_block_split_by_line = self.__get_lines(solution_block)
+            self._parse_res_file_single_solution_block(solution_block_split_by_line)
+
+    def _parse_res_file(self): 
+        self._res_header()
+        self._get_all_solution_blocks()
+        self._parse_res_file_solution_blocks()
+
+    def _write_res_file(self):
+        with open(self._res_file_path, "w") as f:
+            # write header
+            f.write(f"$ResFormat /* {self._write_data.getdp_version}, {self._write_data.encoding} */\n")
+            # write res file format
+            f.write(f"1.1 {self._write_data.res_file_format}\n")
+            f.write(f"$EndResFormat\n")
+
+            self._write_solution_block(f)
+
+    def _write_solution_block(self, f):
+        for time_real, time_imag, time_step, dof_data, solution in zip(self._write_data.solution['time_real'], self._write_data.solution['time_imag'], self._write_data.solution['time_step'], self._write_data.solution['dof_data'], self._write_data.solution['solution']):
+        
+            f.write(f"$Solution  /* DofData #{dof_data} */\n")
+            f.write(f"{dof_data} {time_real:.16g} {time_imag:.16g} {time_step}\n")
+            f.write('\n'.join('{0:.16g}'.format(sol_entry) for sol_entry in solution))
+            f.write(f"\n$EndSolution\n")
+
+# ==============================================================================
+#parsedRes = ParserRES('test.res')
+#ParserRES('test_written.res', write_data=parsedRes)
+#import filecmp 
 #print(filecmp.cmp('test.res', 'test_written.res'))

fiqus/plotters/PlotPythonCCT.py

@@ -1,134 +1,134 @@
-import os
-from operator import le, ge
-
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-from matplotlib.pyplot import cm
-from mpl_toolkits.mplot3d.art3d import Poly3DCollection
-
-from fiqus.geom_generators.GeometryCCT import Winding, FQPL
-
-
-class PlotPythonCCT:
-    def __init__(self, fdm, verbose=True):
-        """
-        Class to cct models postprocessing
-        :param fdm: FiQuS data model
-        :param verbose: If True more information is printed in python console.
-        """
-        self.cctdm = fdm.magnet
-        self.model_folder = os.path.join(os.getcwd())
-        self.magnet_name = fdm.general.magnet_name
-
-        self.verbose = verbose
-        # self.gu = GmshUtils(self.model_folder, self.verbose)
-        # self.gu.initialize()
-
-    def plot_elements_file(self, lfes=None):
-        field_map_3D_csv = 'field_map_3D.csv'
-        df = pd.read_csv(field_map_3D_csv, delimiter=',', engine='python')
-        sAvePositions = df['sAvePositions [m]'].to_numpy(dtype='float')[:-1]  # [:-1] to remove last nan
-        ph_order = df['nodeToPhysicalTurn [-]'].to_numpy(dtype='int')[:-1]  # physical turns, [:-1] to remove last nan
-        el_order = df['nodeToHalfTurn [-]'].to_numpy(dtype='int')[:-1]  # electric order turns, [:-1] to remove last nan
-        x3Dsurf_1 = df['x3Dsurf 1 [m]'].to_numpy(dtype='float')
-        y3Dsurf_1 = df['y3Dsurf 1 [m]'].to_numpy(dtype='float')
-        z3Dsurf_1 = df['z3Dsurf 1 [m]'].to_numpy(dtype='float')
-        el_order_unique = np.unique(el_order)
-
-        per_turn = False
-
-        fig = plt.figure(figsize=(16, 10))
-        ax = fig.add_subplot(111, projection='3d', proj_type='ortho')
-
-        if per_turn:
-            colors = cm.rainbow(np.linspace(0, 1, np.shape(el_order_unique)[0]))
-            for idx_turn, el_u in enumerate(el_order_unique.tolist()):
-                indexes = np.where(el_u == el_order)[0]
-                min_idx=np.min(indexes)
-                max_idx=np.max(indexes+2)
-                ax.plot(x3Dsurf_1[min_idx:max_idx], y3Dsurf_1[min_idx:max_idx], z3Dsurf_1[min_idx:max_idx], color=colors[idx_turn])
-        else:
-            ax.plot(x3Dsurf_1, y3Dsurf_1, z3Dsurf_1)
-        # colors = cm.rainbow(np.linspace(0, 1, np.shape(x3Dsurf_1)[0]))
-        # # ax.plot(x3Dsurf_1, y3Dsurf_1, z3Dsurf_1)
-
-        # for idx in range(np.shape(x3Dsurf_1)[0]-1):
-        #     ax.plot([x3Dsurf_1[idx], x3Dsurf_1[idx+1]], [y3Dsurf_1[idx], y3Dsurf_1[idx+1]], [z3Dsurf_1[idx], z3Dsurf_1[idx+1]], color=colors[idx])
-        # xmin, xmax, ymin, ymax, zmin, zmax = (0, 0, 0, 0, 0, 0)
-        # #colors = cm.rainbow(np.linspace(0, 1, len(objects_list)))
-        # ax.set_box_aspect((xmax - xmin, ymax - ymin, zmax - zmin))  # set axis to data aspect ratio
-        # ax.set_xlim([xmin, xmax])
-        # ax.set_ylim([ymin, ymax])
-        # ax.set_zlim([zmin, zmax])
-        ax.set_xlabel('x (m)')
-        ax.set_ylabel('y (m)')
-        ax.set_zlabel('z (m)')
-        ax.view_init(elev=90, azim=0, vertical_axis='x')
-        plt.show()
-        pass
-
-    def plot_elements_computed(self, lfes=None):
-        """
-        Makes a plot oh hexahedra by calculating 'on the fly' what is defined in the yaml data model for cct magnet.
-        :param lfes: list with numbers of elements to put text labels on. For two windings an example would be [[3], [9]] to plot 3rd hex in the first winding and 9th in the second
-        :return: Nothing. A matplotlib graph pops up on the screen.
-        """
-
-        windings = []
-        fqpls = []
-        for ww, _ in enumerate(self.cctdm.geometry.windings.names):
-            winding_obj = Winding(self.cctdm, ww, post_proc=True)
-            windings.append(winding_obj)
-        for ff, _ in enumerate(self.cctdm.geometry.fqpls.names):
-            fqpl_obj = FQPL(self.cctdm, ff)
-            fqpls.append(fqpl_obj)
-        objects_list = windings + fqpls
-        if not lfes:
-            lfes = [[] for _ in objects_list]  # make it work if lfes is not supplied as input.
-
-        def val_check(var, array, oper, func):
-            new = func(array)
-            if oper(new, var):
-                return new
-            else:
-                return var
-
-        fig = plt.figure(figsize=(16, 10))
-        ax = fig.add_subplot(111, projection='3d', proj_type='ortho')
-        xmin, xmax, ymin, ymax, zmin, zmax = (0, 0, 0, 0, 0, 0)
-        colors = cm.rainbow(np.linspace(0, 1, len(objects_list)))
-        for obj, lfe, fc in zip(objects_list, lfes, colors):
-            xs = []
-            ys = []
-            zs = []
-            hexes = obj.hexes
-            vts = obj.vertices_to_surf
-            for elem_num, points_dict in hexes.items():
-                list_of_coor_tuples = []
-                points_dict.pop('ct', None)  # removing turn from dict
-                for p_num, p_coords in points_dict.items():
-
-                    list_of_coor_tuples.append((p_coords['x'], p_coords['y'], p_coords['z']))
-                    if elem_num in lfe:
-                        ax.scatter(p_coords['x'], p_coords['y'], p_coords['z'])
-                        ax.text(p_coords['x'], p_coords['y'], p_coords['z'], f'{p_num}', zdir='z')
-                    for coor_acc, coor_key in zip([xs, ys, zs], ['x', 'y', 'z']):
-                        coor_acc.append(p_coords[coor_key])
-                poly3d = [[list_of_coor_tuples[vts[ix][iy]] for iy in range(len(vts[0]))] for ix in range(len(vts))]
-                ax.add_collection3d(Poly3DCollection(poly3d, edgecolors='k', facecolors=fc, linewidths=0.5, alpha=0.5))
-            xmin = val_check(xmin, xs, le, np.min)
-            xmax = val_check(xmax, xs, ge, np.max)
-            ymin = val_check(ymin, ys, le, np.min)
-            ymax = val_check(ymax, ys, ge, np.max)
-            zmin = val_check(zmin, zs, le, np.min)
-            zmax = val_check(zmax, zs, ge, np.max)
-        ax.set_box_aspect((xmax - xmin, ymax - ymin, zmax - zmin))  # set axis to data aspect ratio
-        ax.set_xlim([xmin, xmax])
-        ax.set_ylim([ymin, ymax])
-        ax.set_zlim([zmin, zmax])
-        ax.set_xlabel('x (m)')
-        ax.set_ylabel('y (m)')
-        ax.set_zlabel('z (m)')
-        ax.view_init(elev=90, azim=0, vertical_axis='x')
+import os
+from operator import le, ge
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib.pyplot import cm
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+
+from fiqus.geom_generators.GeometryCCT import Winding, FQPL
+
+
+class PlotPythonCCT:
+    def __init__(self, fdm, verbose=True):
+        """
+        Class to cct models postprocessing
+        :param fdm: FiQuS data model
+        :param verbose: If True more information is printed in python console.
+        """
+        self.cctdm = fdm.magnet
+        self.model_folder = os.path.join(os.getcwd())
+        self.magnet_name = fdm.general.magnet_name
+
+        self.verbose = verbose
+        # self.gu = GmshUtils(self.model_folder, self.verbose)
+        # self.gu.initialize()
+
+    def plot_elements_file(self, lfes=None):
+        field_map_3D_csv = 'field_map_3D.csv'
+        df = pd.read_csv(field_map_3D_csv, delimiter=',', engine='python')
+        sAvePositions = df['sAvePositions [m]'].to_numpy(dtype='float')[:-1]  # [:-1] to remove last nan
+        ph_order = df['nodeToPhysicalTurn [-]'].to_numpy(dtype='int')[:-1]  # physical turns, [:-1] to remove last nan
+        el_order = df['nodeToHalfTurn [-]'].to_numpy(dtype='int')[:-1]  # electric order turns, [:-1] to remove last nan
+        x3Dsurf_1 = df['x3Dsurf 1 [m]'].to_numpy(dtype='float')
+        y3Dsurf_1 = df['y3Dsurf 1 [m]'].to_numpy(dtype='float')
+        z3Dsurf_1 = df['z3Dsurf 1 [m]'].to_numpy(dtype='float')
+        el_order_unique = np.unique(el_order)
+
+        per_turn = False
+
+        fig = plt.figure(figsize=(16, 10))
+        ax = fig.add_subplot(111, projection='3d', proj_type='ortho')
+
+        if per_turn:
+            colors = cm.rainbow(np.linspace(0, 1, np.shape(el_order_unique)[0]))
+            for idx_turn, el_u in enumerate(el_order_unique.tolist()):
+                indexes = np.where(el_u == el_order)[0]
+                min_idx=np.min(indexes)
+                max_idx=np.max(indexes+2)
+                ax.plot(x3Dsurf_1[min_idx:max_idx], y3Dsurf_1[min_idx:max_idx], z3Dsurf_1[min_idx:max_idx], color=colors[idx_turn])
+        else:
+            ax.plot(x3Dsurf_1, y3Dsurf_1, z3Dsurf_1)
+        # colors = cm.rainbow(np.linspace(0, 1, np.shape(x3Dsurf_1)[0]))
+        # # ax.plot(x3Dsurf_1, y3Dsurf_1, z3Dsurf_1)
+
+        # for idx in range(np.shape(x3Dsurf_1)[0]-1):
+        #     ax.plot([x3Dsurf_1[idx], x3Dsurf_1[idx+1]], [y3Dsurf_1[idx], y3Dsurf_1[idx+1]], [z3Dsurf_1[idx], z3Dsurf_1[idx+1]], color=colors[idx])
+        # xmin, xmax, ymin, ymax, zmin, zmax = (0, 0, 0, 0, 0, 0)
+        # #colors = cm.rainbow(np.linspace(0, 1, len(objects_list)))
+        # ax.set_box_aspect((xmax - xmin, ymax - ymin, zmax - zmin))  # set axis to data aspect ratio
+        # ax.set_xlim([xmin, xmax])
+        # ax.set_ylim([ymin, ymax])
+        # ax.set_zlim([zmin, zmax])
+        ax.set_xlabel('x (m)')
+        ax.set_ylabel('y (m)')
+        ax.set_zlabel('z (m)')
+        ax.view_init(elev=90, azim=0, vertical_axis='x')
+        plt.show()
+        pass
+
+    def plot_elements_computed(self, lfes=None):
+        """
+        Makes a plot oh hexahedra by calculating 'on the fly' what is defined in the yaml data model for cct magnet.
+        :param lfes: list with numbers of elements to put text labels on. For two windings an example would be [[3], [9]] to plot 3rd hex in the first winding and 9th in the second
+        :return: Nothing. A matplotlib graph pops up on the screen.
+        """
+
+        windings = []
+        fqpls = []
+        for ww, _ in enumerate(self.cctdm.geometry.windings.names):
+            winding_obj = Winding(self.cctdm, ww, post_proc=True)
+            windings.append(winding_obj)
+        for ff, _ in enumerate(self.cctdm.geometry.fqpls.names):
+            fqpl_obj = FQPL(self.cctdm, ff)
+            fqpls.append(fqpl_obj)
+        objects_list = windings + fqpls
+        if not lfes:
+            lfes = [[] for _ in objects_list]  # make it work if lfes is not supplied as input.
+
+        def val_check(var, array, oper, func):
+            new = func(array)
+            if oper(new, var):
+                return new
+            else:
+                return var
+
+        fig = plt.figure(figsize=(16, 10))
+        ax = fig.add_subplot(111, projection='3d', proj_type='ortho')
+        xmin, xmax, ymin, ymax, zmin, zmax = (0, 0, 0, 0, 0, 0)
+        colors = cm.rainbow(np.linspace(0, 1, len(objects_list)))
+        for obj, lfe, fc in zip(objects_list, lfes, colors):
+            xs = []
+            ys = []
+            zs = []
+            hexes = obj.hexes
+            vts = obj.vertices_to_surf
+            for elem_num, points_dict in hexes.items():
+                list_of_coor_tuples = []
+                points_dict.pop('ct', None)  # removing turn from dict
+                for p_num, p_coords in points_dict.items():
+
+                    list_of_coor_tuples.append((p_coords['x'], p_coords['y'], p_coords['z']))
+                    if elem_num in lfe:
+                        ax.scatter(p_coords['x'], p_coords['y'], p_coords['z'])
+                        ax.text(p_coords['x'], p_coords['y'], p_coords['z'], f'{p_num}', zdir='z')
+                    for coor_acc, coor_key in zip([xs, ys, zs], ['x', 'y', 'z']):
+                        coor_acc.append(p_coords[coor_key])
+                poly3d = [[list_of_coor_tuples[vts[ix][iy]] for iy in range(len(vts[0]))] for ix in range(len(vts))]
+                ax.add_collection3d(Poly3DCollection(poly3d, edgecolors='k', facecolors=fc, linewidths=0.5, alpha=0.5))
+            xmin = val_check(xmin, xs, le, np.min)
+            xmax = val_check(xmax, xs, ge, np.max)
+            ymin = val_check(ymin, ys, le, np.min)
+            ymax = val_check(ymax, ys, ge, np.max)
+            zmin = val_check(zmin, zs, le, np.min)
+            zmax = val_check(zmax, zs, ge, np.max)
+        ax.set_box_aspect((xmax - xmin, ymax - ymin, zmax - zmin))  # set axis to data aspect ratio
+        ax.set_xlim([xmin, xmax])
+        ax.set_ylim([ymin, ymax])
+        ax.set_zlim([zmin, zmax])
+        ax.set_xlabel('x (m)')
+        ax.set_ylabel('y (m)')
+        ax.set_zlabel('z (m)')
+        ax.view_init(elev=90, azim=0, vertical_axis='x')
         plt.show()