fiqus 2025.11.0__py3-none-any.whl → 2025.12.0__py3-none-any.whl

fiqus/mesh_generators/MeshHomogenizedConductor.py

@@ -0,0 +1,229 @@
+import os, json, gmsh
+
+from fiqus.data import RegionsModelFiQuS
+from fiqus.utils.Utils import GmshUtils, FilesAndFolders
+from fiqus.data.RegionsModelFiQuS import RegionsModel
+    
+class Mesh:
+    def __init__(self, fdm, verbose=True):
+        """
+        A base-class used to manage the mesh for HomogenizedConductor model.
+
+        :ivar fdm: The fiqus data model for input parameters.
+        :vartype fdm: dict
+        """
+        self.fdm = fdm
+        self.mesh_folder = os.path.join(os.getcwd())
+        self.geom_folder = os.path.dirname(self.mesh_folder)
+        self.mesh_file = os.path.join(self.mesh_folder, f"{self.fdm.general.magnet_name}.msh")
+        self.regions_file = os.path.join(self.mesh_folder, f"{self.fdm.general.magnet_name}.regions")
+        self.vi_file = os.path.join(self.geom_folder, f'{self.fdm.general.magnet_name}.vi')
+        self.verbose = verbose
+
+        # dictionaries for physical groups
+        self.dimTags_physical_surfaces = {}
+        self.dimTags_physical_boundaries = {}
+        self.dimTags_physical_cuts = {}
+        self.dimTags_physical_points ={}
+
+        # Read volume information file:
+        with open(self.vi_file, "r") as f:
+            self.dimTags = json.load(f)
+
+        for key, value in self.dimTags.items():
+            self.dimTags[key] = tuple(value) # dimTags contains all surfaces
+
+        self.gu = GmshUtils(self.mesh_folder, self.verbose)
+        self.gu.initialize(verbosity_Gmsh=fdm.run.verbosity_Gmsh)
+
+        gmsh.option.setNumber("General.Terminal", verbose)
+
+    def generate_mesh(self):
+        """ This function generates a mesh based on the volume information (vi) file created in the geometry step and the yaml input. """
+
+        self.generate_physical_groups()
+
+        # scale by domain size
+        domain_size = self.fdm.magnet.geometry.air.radius
+        # Mesh size field for cables:
+        strand_field = gmsh.model.mesh.field.add("Constant")
+        gmsh.model.mesh.field.setNumbers(strand_field, "SurfacesList", [value[1] for key, value in self.dimTags.items() if 'Cable' in key])
+        gmsh.model.mesh.field.setNumber(strand_field, "VIn", self.fdm.magnet.mesh.cable_mesh_size_ratio * domain_size)
+        # Mesh size field for excitation coils:
+        coil_field = gmsh.model.mesh.field.add("Constant")
+        gmsh.model.mesh.field.setNumbers(coil_field, "SurfacesList", [value[1] for key, value in self.dimTags.items() if 'Coil' in key])
+        gmsh.model.mesh.field.setNumber(coil_field, "VIn", self.fdm.magnet.mesh.cable_mesh_size_ratio * domain_size)
+        # Mesh size field for air:
+        air_field = gmsh.model.mesh.field.add("Constant")
+        gmsh.model.mesh.field.setNumbers(air_field, "SurfacesList", [self.dimTags['Air'][1]])
+        gmsh.model.mesh.field.setNumber(air_field, "VIn", self.fdm.magnet.mesh.air_boundary_mesh_size_ratio * domain_size)
+
+        total_meshSize_field = gmsh.model.mesh.field.add("Min")
+        gmsh.model.mesh.field.setNumbers(total_meshSize_field, "FieldsList", [strand_field, coil_field, air_field])
+        gmsh.model.mesh.field.setAsBackgroundMesh(total_meshSize_field)
+
+        gmsh.option.setNumber("Mesh.MeshSizeFactor", self.fdm.magnet.mesh.scaling_global)
+        gmsh.model.mesh.generate(2)
+
+
+    def generate_physical_groups(self):
+        """ This function generates the physical groups within the mesh based on the volume information (vi) file and stores their tags in dictionaries.
+
+        :raises ValueError: For unknown volume names in the vi-file
+        """
+        gmsh.model.occ.synchronize()
+
+        for key, value in self.dimTags.items():
+            # surface
+            surf_tag = gmsh.model.addPhysicalGroup(dim=value[0], tags=[value[1]], name=key)
+            self.dimTags_physical_surfaces.update({str(key):(2, surf_tag)})
+            # (outer) boundary curves
+            if 'Air' in key:
+                boundary_curves = gmsh.model.get_boundary([tuple(val) for val in self.dimTags.values()], combined=True)
+            elif 'Cable' in key:
+                boundary_curves = gmsh.model.get_boundary([tuple(value)]) 
+            elif 'Coil' in key:
+                boundary_curves = gmsh.model.get_boundary([tuple(value)]) 
+            else:
+                raise ValueError('Unknown volume in declaration in VI file.')
+            bnd_tag = gmsh.model.addPhysicalGroup(dim=1, tags=[dimTag[1] for dimTag in boundary_curves], name=key+'Boundary' )
+            self.dimTags_physical_boundaries.update({str(key+'Boundary' ):(1, bnd_tag)})
+            # arbitrary boundary point
+            point_tag = gmsh.model.addPhysicalGroup(dim=0, tags=[gmsh.model.get_boundary(boundary_curves, combined=False)[0][1]], name=key+'BoundaryPoint' )
+            self.dimTags_physical_points.update({str(key+'BoundaryPoint' ):(1, point_tag)})
+
+
+    def generate_cuts(self):
+        """ This function generates and orients the domain cuts for the cable and coil regions through the gmsh internal homology module."""
+
+        dimTags_physical_cable_boundaries = {k: v for k, v in self.dimTags_physical_boundaries.items() if 'Cable' in k}
+        dimTags_physical_excitation_coil_boundaries = {k: v for k, v in self.dimTags_physical_boundaries.items() if 'Coil' in k}
+
+        tags_physical_cable_surfaces = [v[1] for k, v in self.dimTags_physical_surfaces.items() if 'Cable' in k]
+        tags_physical_excitation_coil_surfaces = [v[1] for k, v in self.dimTags_physical_surfaces.items() if 'Coil' in k]
+        
+        # print(dimTags_physical_cable_boundaries)
+        # print(dimTags_physical_excitation_coil_boundaries)
+        # print(tags_physical_cable_surfaces)
+        # print(tags_physical_excitation_coil_surfaces)
+
+        # cohomology cuts for all cables
+        for _, value in dimTags_physical_cable_boundaries.items():
+            gmsh.model.mesh.addHomologyRequest("Homology", domainTags=[value[1]], dims=[1])
+        for _, value in dimTags_physical_excitation_coil_boundaries.items():
+            gmsh.model.mesh.addHomologyRequest("Homology", domainTags=[value[1]], dims=[1])
+
+        gmsh.model.mesh.addHomologyRequest("Cohomology", domainTags=[self.dimTags_physical_surfaces['Air'][1]]+tags_physical_excitation_coil_surfaces, dims=[1])
+        for coil_surface in tags_physical_excitation_coil_surfaces:
+            tags_physical_excitation_other_coil_surfaces = [other_coil for other_coil in tags_physical_excitation_coil_surfaces if other_coil != coil_surface]
+            gmsh.model.mesh.addHomologyRequest("Cohomology", domainTags=[self.dimTags_physical_surfaces['Air'][1]]+tags_physical_cable_surfaces+tags_physical_excitation_other_coil_surfaces, dims=[1])
+
+
+
+        dimTags_homology = gmsh.model.mesh.computeHomology()
+        # print(dimTags_homology)
+        dimTags_bnds = dimTags_homology[:int(len(dimTags_homology)/2)] # first half are dimTags are the cut boundaries
+        dimTags_cuts = dimTags_homology[int(len(dimTags_homology)/2):] # second half are the actual cut edges
+        gmsh.model.mesh.clearHomologyRequests()
+        
+        # post process homology cuts
+        bnd_tags = []
+        cut_tags = []
+        for i in range(len(dimTags_physical_cable_boundaries)):
+            self.dimTags_physical_cuts.update({'Cable'+str(i+1)+'Cut':(1, dimTags_cuts[-1][1]+(i+1))}) # +1 tag shift for post processed cuts
+            bnd_tags.append(dimTags_bnds[i][1])
+            cut_tags.append(dimTags_cuts[i][1])
+        for i in range(len(dimTags_physical_excitation_coil_boundaries)):
+            self.dimTags_physical_cuts.update({'Coil'+str(i+1)+'Cut':(1, dimTags_cuts[-1][1]+(len(dimTags_physical_cable_boundaries)+i+1))}) # +1 tag shift for post processed cuts
+            bnd_tags.append(dimTags_bnds[len(dimTags_physical_cable_boundaries)+i][1])
+            cut_tags.append(dimTags_cuts[len(dimTags_physical_cable_boundaries)+i][1])
+        gmsh.plugin.setString("HomologyPostProcessing", "PhysicalGroupsOfOperatedChains", ','.join(map(str,bnd_tags)))
+        gmsh.plugin.setString("HomologyPostProcessing", "PhysicalGroupsOfOperatedChains2", ','.join(map(str,cut_tags)))
+        gmsh.plugin.run("HomologyPostProcessing")
+
+
+    def generate_regions_file(self):
+        """
+        Generates a .regions file for the GetDP solver, containing all necessary information about the model.
+        The regions model contains data about physical surfaces, boundaries, points and cuts and is stored in the mesh folder.
+
+        :raises ValueError: For unknown volumes in the vi-file
+        """
+        regions_model = RegionsModel()
+
+        # The region Cables will include the homogenized surfaces
+        regions_model.powered['Cables'] = RegionsModelFiQuS.Powered()
+        regions_model.powered['Cables'].vol.names = []
+        regions_model.powered['Cables'].vol.numbers = []
+        regions_model.powered['Cables'].surf.names = []
+        regions_model.powered['Cables'].surf.numbers = [] 
+        regions_model.powered['Cables'].curve.names = []
+        regions_model.powered['Cables'].curve.numbers = [] 
+        regions_model.powered['Cables'].cochain.names = []
+        regions_model.powered['Cables'].cochain.numbers = [] 
+        # Excitation coil regions
+        regions_model.powered['ExcitationCoils'] = RegionsModelFiQuS.Powered()
+        regions_model.powered['ExcitationCoils'].vol.names = []
+        regions_model.powered['ExcitationCoils'].vol.numbers = []
+        regions_model.powered['ExcitationCoils'].surf.names = []
+        regions_model.powered['ExcitationCoils'].surf.numbers = [] 
+        regions_model.powered['ExcitationCoils'].curve.names = []
+        regions_model.powered['ExcitationCoils'].curve.numbers = [] 
+        regions_model.powered['ExcitationCoils'].cochain.names = []
+        regions_model.powered['ExcitationCoils'].cochain.numbers = [] 
+       
+        gmsh.model.occ.synchronize()
+        for name in self.dimTags.keys():
+            cut_name = name+'Cut'
+            boundary_name = name+'Boundary'
+            point_name = boundary_name+'Point'
+            if 'Air' in name:
+                regions_model.air.vol.number = self.dimTags_physical_surfaces[name][1]
+                regions_model.air.vol.name = "Air"
+                regions_model.air.surf.number = self.dimTags_physical_boundaries[boundary_name][1]
+                regions_model.air.surf.name = boundary_name
+                regions_model.air.point.names = [point_name]
+                regions_model.air.point.numbers = [self.dimTags_physical_points[point_name][1]]
+            elif 'Cable' in name:
+                regions_model.powered['Cables'].vol.names.append(name)
+                regions_model.powered['Cables'].vol.numbers.append(self.dimTags_physical_surfaces[name][1])
+                regions_model.powered['Cables'].surf.names.append(boundary_name)
+                regions_model.powered['Cables'].surf.numbers.append(self.dimTags_physical_boundaries[boundary_name][1])
+                regions_model.powered['Cables'].curve.names.append(point_name)
+                regions_model.powered['Cables'].curve.numbers.append(self.dimTags_physical_points[point_name][1])
+                regions_model.powered['Cables'].cochain.names.append(cut_name)
+                regions_model.powered['Cables'].cochain.numbers.append(self.dimTags_physical_cuts[cut_name][1])
+            elif 'Coil' in name:
+                regions_model.powered['ExcitationCoils'].vol.names.append(name)
+                regions_model.powered['ExcitationCoils'].vol.numbers.append(self.dimTags_physical_surfaces[name][1])
+                regions_model.powered['ExcitationCoils'].surf.names.append(boundary_name)
+                regions_model.powered['ExcitationCoils'].surf.numbers.append(self.dimTags_physical_boundaries[boundary_name][1])
+                regions_model.powered['ExcitationCoils'].curve.names.append(point_name)
+                regions_model.powered['ExcitationCoils'].curve.numbers.append(self.dimTags_physical_points[point_name][1])
+                regions_model.powered['ExcitationCoils'].cochain.names.append(cut_name)
+                regions_model.powered['ExcitationCoils'].cochain.numbers.append(self.dimTags_physical_cuts[cut_name][1])
+            else:
+                raise ValueError('Unknown physical region')
+
+        FilesAndFolders.write_data_to_yaml(self.regions_file, regions_model.model_dump())
+
+    def save_mesh(self, gui: bool = False):
+        """ Saves the mesh to a .msh file. If gui is True, the mesh is also loaded in the gmsh GUI. """
+        
+        gmsh.write(self.mesh_file)
+        if gui:
+            self.gu.launch_interactive_GUI()
+        else:
+            if gmsh.isInitialized():
+                gmsh.clear()
+                gmsh.finalize()
+
+    def load_mesh(self, gui : bool = False):
+        """ Loads a previously generated mesh. """
+        
+        gmsh.clear()
+        gmsh.open(self.mesh_file)
+
+        if gui:
+            self.gu.launch_interactive_GUI()
+

fiqus/post_processors/PostProcessAC_Rutherford.py

@@ -0,0 +1,142 @@
+import os, logging
+import numpy as np
+import matplotlib.pyplot as plt
+
+logger = logging.getLogger('FiQuS')
+
+class PostProcess:
+    def __init__(self, solution_folder_path):
+        self.solution_folder_path = solution_folder_path
+
+        self.plot_transport()
+        # self.plot_strand_split()
+        self.plot_fluxhyst()
+        self.plot_power_rohf()
+
+    def load_standard_txt(self, file_rel_path, skiprows=1):
+        """Load the content of a txt file into a nested numpy array
+
+        :param file_rel_path: relative file path in the solution folder (with file extension)
+        :param skiprows: number of rows to skip at the top of the txt file, defaults to 1
+        :return: nested np.array with time at index 0
+        """
+        file_path = os.path.join(self.solution_folder_path, file_rel_path)
+        return np.loadtxt(file_path, skiprows=skiprows).T if os.path.isfile(file_path) else None
+
+    def plot_transport(self):
+        """ Plots transport current and voltage over time if existing """
+
+        Vt_data = self.load_standard_txt('txt_files\\Vt.txt')
+        It_data = self.load_standard_txt('txt_files\\It.txt') 
+
+        if all(x is not None for x in (It_data, Vt_data)):
+            fig, ax1 = plt.subplots()
+            ax1.set_title("Transport current and voltage")
+            ax1.set_xlabel(r'Time $(s)$')
+            ax1.set_ylabel(r'Current $(A)$', color = 'red')
+            ax1.plot(It_data[0], It_data[1], color = 'red')
+            ax1.grid(axis='x', linestyle='dotted')
+            ax1.tick_params(axis='y', labelcolor = 'red')
+            
+            ax2 = ax1.twinx()
+            ax2.set_ylabel(r'Voltage $(V)$', color = 'blue')
+            ax2.plot(Vt_data[0], Vt_data[1], color = 'blue')
+            ax2.tick_params(axis='y', labelcolor = 'blue')
+            ax2.grid(axis='y', linestyle='dotted')
+            fig.tight_layout()
+
+    def plot_fluxhyst(self):
+        """ Plots the internal flux hysteresis and resulting voltages if existing (ROHF enabled and stranded strands) """
+
+        fluxhyst_data = self.load_standard_txt('txt_files\\flux_hyst.txt')
+        voltage_rohf = self.load_standard_txt('txt_files\\voltage_rohf.txt')
+        Is_data = self.load_standard_txt('txt_files\\Is.txt')  
+
+        if all(x is not None for x in (fluxhyst_data, Is_data)):
+            # plot only the first quarter of the strands because of symmetry ...
+            q_idx = round((len(fluxhyst_data)-1) / 4)
+            colors = plt.cm.rainbow(np.linspace(0,1,q_idx))
+            plt.figure(figsize=(10,5))
+            # Flux in strand currents
+            plt.subplot(121)
+            plt.title('ROHF Flux hysteresis')
+            for i in range(1,q_idx+1):
+                plt.plot(Is_data[i], fluxhyst_data[i], label='Strand '+str(i), color=colors[i-1]) 
+            plt.xlabel(r"Strand current (A)")
+            plt.ylabel(r'Internal flux (Wb/m$)')
+            plt.legend()  
+
+            # Resulting strand ROHF voltages
+            plt.subplot(122)
+            plt.title('ROHF voltages')
+            if voltage_rohf is not None:
+                for i in range(1, q_idx+1):
+                    plt.plot(voltage_rohf[0], voltage_rohf[i], label='Strand '+str(i), color=colors[i-1])
+                    #plt.plot(self.linflux_voltage[0], self.linflux_voltage[i], linestyle='dashed', color=colors[i-1])
+            plt.xlabel('Time (s)')
+            plt.ylabel(r'Voltage (V/m)')
+            plt.legend()
+
+    def plot_strand_split(self):
+        """ Plots the Strand currents and voltages for stranded strands enabled """
+
+        Vt_data = self.load_standard_txt('txt_files\\Vt.txt')
+        It_data = self.load_standard_txt('txt_files\\It.txt') 
+        Vs_data = self.load_standard_txt('txt_files\\Vs.txt')
+        Is_data = self.load_standard_txt('txt_files\\Is.txt')  
+
+        if all(x is not None for x in (It_data, Vt_data, Is_data, Vs_data)):
+            # plot only the first quarter of the strands because of symmetry ...
+            q_idx = round((len(Vs_data)-1) / 4)
+            colors = plt.cm.rainbow(np.linspace(0,1,q_idx))
+
+            plt.figure(figsize=(9,5))
+            plt.subplot(121)
+            plt.title('Strand voltages')
+            plt.plot(Vt_data[0], Vt_data[1], label='Total transport voltage')
+            for i in range(1,q_idx+1):
+                plt.plot(Vs_data[0], Vs_data[i], label='Strand '+str(i), color=colors[i-1])  
+            plt.plot(Vs_data[0], sum(Vs_data[1:]), 'r.--', label=r'$\sum \ V_s$')
+            #plt.scatter(self.Vs_data[0], self.Vs_data[36], marker='x', label='Strand 36')
+            plt.xlabel(r"Time (s)")
+            plt.ylabel(r'Voltage (V/m)')
+            plt.legend()       
+
+            plt.subplot(122)
+            plt.title('Strand currents')
+            plt.plot(It_data[0], It_data[1], label='Total transport current')
+            for i in range(1,q_idx+1):
+                plt.plot(Is_data[0], Is_data[i], label='Strand '+str(i), color=colors[i-1])
+            plt.plot(Is_data[0], sum(Is_data[1:]), 'r.--', label=r'$\sum \ I_s$')  
+            #plt.scatter(self.Is_data[0], self.Is_data[36], marker='x', label='Strand 36')
+            plt.xlabel(r"Time (s)")
+            plt.ylabel(r'Current (A)')       
+            plt.legend()  
+
+    def plot_power_rohf(self):
+        """ Plots the ROHF related power contributions if existing """
+
+        power = self.load_standard_txt('txt_files\\power.txt')
+        power_hyst_rohf = self.load_standard_txt('txt_files\\power_hyst_ROHF.txt')
+        power_eddy_rohf = self.load_standard_txt('txt_files\\power_eddy_ROHF.txt')
+
+        if power is not None and len(power) == 5:
+            colors = plt.cm.rainbow(np.linspace(0,1,4))
+
+            plt.figure()
+            plt.title('Instantaneous power loss contributions')
+            #plt.plot(self.power[0], self.power[1], label='Total', color=colors[0])   
+            plt.plot(power[0], power[2], label='hyst powerfile', linestyle='--', color=colors[1])
+            plt.plot(power_hyst_rohf[0], sum(power_hyst_rohf[1:]), label='Hyst', color=colors[1])
+            plt.plot(power[0], power[3], label='Eddy powerfile', linestyle='--', color=colors[2])
+            plt.plot(power_eddy_rohf[0], sum(power_eddy_rohf[1:]), label='Eddy', color=colors[2]) 
+            #plt.plot(power_hyst_strands[0], sum(power_hyst_strands[1:]), label='strands sum')
+            plt.xlabel(r"Time (s)")
+            plt.ylabel(r'Power loss (W/m)') 
+            plt.legend()
+        
+    def show(self):
+        """ Display all generated plots at once """
+        plt.show() if len(plt.get_fignums()) > 0 else logger.info('- NO POSTPROC DATA -')
+
+

fiqus/post_processors/PostProcessHomogenizedConductor.py

@@ -0,0 +1,114 @@
+import os, re, logging
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+
+logger = logging.getLogger('FiQuS')
+
+
+class PostProcess():
+    """Class for python post processing of HomogenizedConductor simulations"""
+    def __init__(self, fdm, solution_folder_path):
+        self.fdm = fdm
+        self.solution_folder_path = solution_folder_path
+        # try to create ROHF plots
+        self.plot_density_lines()
+        self.fluxhyst()
+        self.power_loss()
+    
+    def load_standard_txt(self, rel_file_path, skiprows=0, transpose=True):
+        """This function loads standards txt files within the solution folder to numpy arrays.
+
+        :param rel_file_path: relative path with file extension within the solution folder
+        """
+        abs_file_path = os.path.join(self.solution_folder_path, rel_file_path)
+        data = None
+        if os.path.isfile(abs_file_path):
+            data = np.loadtxt(abs_file_path, skiprows=skiprows).T if transpose else np.loadtxt(abs_file_path, skiprows=skiprows)
+        return data
+    
+    def fluxhyst(self):
+        """This function tries to load and display the flux hysteresis (ROHF activated) in the solution data."""
+
+        fluxhyst = self.load_standard_txt('txt_files\\fluxhyst.txt')
+        #flux_average = self.load_standard_txt('txt_files\\flux_density_avg.txt')
+        #flux_strand = self.load_standard_txt('txt_files\\flux_density_strand_avg.txt')
+        
+        voltage_rohf = self.load_standard_txt('txt_files\\voltage_rohf.txt')
+        It = self.load_standard_txt('txt_files\\It.txt', skiprows=1)
+        
+        if fluxhyst is not None and It is not None:
+            plt.figure(figsize=(10,5))
+            plt.subplot(121)
+            plt.title('Flux hysteresis')
+            plt.plot(It[1], fluxhyst[1])
+            #plt.plot(It[1], fluxhyst[1] - mu_0/(4*pi) * It[1])
+            plt.xlabel('Transport current (A)')
+            plt.ylabel('Internal Flux (Tm)')
+            #plt.legend()
+            
+            plt.subplot(122)
+            plt.title('ROHF voltage (unit length)')
+            if voltage_rohf is not None: plt.plot(voltage_rohf[0], voltage_rohf[1])
+            plt.xlabel('Time (s)')
+            plt.ylabel('Voltage (V)')
+            #plt.legend()
+        else:
+            logger.error("POSTPROC: No flux hysteresis data")
+
+    def plot_density_lines(self):
+
+        fluxdens_line = self.load_standard_txt('txt_files\\flux_density_line.txt', transpose=False)
+        currentdens_line = self.load_standard_txt('txt_files\\current_density_line.txt', transpose=False)
+        It = self.load_standard_txt('txt_files\\It.txt')
+        
+        idx = 10
+
+        if fluxdens_line is not None and It is not None:
+            N_steps = len(It[0])
+            time = fluxdens_line[idx][1]
+            x_vals = np.zeros(200)
+            fluxdens = np.zeros(200)
+            for i in range(0,200):
+                x_vals[i] = fluxdens_line[idx+i*N_steps][2]
+                fluxdens[i] = fluxdens_line[idx+i*N_steps][5]
+
+            plt.figure()
+            plt.title('fluxdens at '+str(time) +'s')
+            plt.plot(x_vals, fluxdens)
+            plt.xlabel('Position on x-axis')
+            plt.ylabel('Flux density')
+
+        if currentdens_line is not None and It is not None:
+            N_steps = len(It[0])
+            time = currentdens_line[idx][1]
+            x_vals = np.zeros(200)
+            currentdens = np.zeros(200)
+            for i in range(0,200):
+                x_vals[i] = currentdens_line[idx+i*N_steps][2]
+                currentdens[i] = currentdens_line[idx+i*N_steps][7]
+
+            plt.figure()
+            plt.title('Current denisty at '+str(time) +'s')
+            plt.plot(x_vals, currentdens)
+            plt.xlabel('Position on x-axis')
+            plt.ylabel('Current density')
+
+    def power_loss(self):
+        """This function tries to load and display the power loss from the solution data. Currently only supports ROHF associated losses. """
+
+        power = self.load_standard_txt('txt_files\\power.txt')
+
+        if power is not None and len(power) == 5:
+            plt.figure()
+            plt.title('Instantaneous power losses')
+            plt.plot(power[0], power[2], label=r'$P_{\mathrm{irr}}$')
+            plt.plot(power[0], power[3], label=r'$P_{\mathrm{eddy}}$')
+            plt.plot(power[0], power[4], label=r'$P_{\mathrm{PL}}$')
+            plt.legend()
+        else:
+            logger.error("POSTPROC: no/wrong power data")
+
+    def show(self):
+        """Utility funtion which is called in the end of the python post proc to display all figures at the same time"""
+        plt.show() if len(plt.get_fignums()) > 0 else logger.info('- No postproc figures -')