fsvisual 0.0.1__py3-none-any.whl

fsvisual/brillouin_zone.py

@@ -0,0 +1,35 @@
+from pymatgen.core import Lattice
+
+
+def first_bz(rez_lattice):
+
+    """
+    calculates the edge points of a Brillouin zone for any given reciprocal lattice.
+
+    :param rez_lattice: coordinates for the reciprocal lattice vectors (list of three 3 Dimensional coordinates)
+    :return: 1. Brillouin zone as a list containing x, y, z coordinates on separate lists for each
+    """
+
+    new_lattice = Lattice(rez_lattice)
+    brillouin_zone = new_lattice.get_wigner_seitz_cell()
+
+    # Prepare data for Plotly
+    x, y, z = [], [], []
+    for facet in brillouin_zone:
+        # brillouin zone consists of many facets -> facets consists of vertices (edge points -> koordinates)
+        # Ensure each facet is closed by adding the first vertex at the end
+        facet.append(facet[0])
+        for vertex in facet:
+            x.append(vertex[0])
+            y.append(vertex[1])
+            z.append(vertex[2])
+        # Add None to create a break in the plot lines between facets
+        x.append(None)
+        y.append(None)
+        z.append(None)
+    brillouin_zone_xyz = [x, y, z]
+    return brillouin_zone_xyz, brillouin_zone
+
+
+
+

fsvisual/cli.py

@@ -0,0 +1,68 @@
+from .fermisurface import FermiSurface
+import os
+import argparse
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument( "bxsf_files_directory", help="directory (folder) where the .bxsf files (Fermi"
+                                                             "surface files) are stored")
+
+    # optional arguments
+
+    parser.add_argument("-sf","--save_fermisurfaces", help="directory where visualized Fermi surfaces "
+                                                           "are stored")
+
+    parser.add_argument("-s","--subdivision_surface", help="divides every triangle of the Fermi surface mesh"
+                                                           " into two triangles; executes as many times as the input says",
+                        default=0, type=int)
+
+    parser.add_argument("-dp","--downsampling_surface_percentage", help="lowers the resolution of the "
+                                                            "Fermi surface mesh (number of faces) to a given percentage "
+                                                            "(from original face count)",default=100, type=int)
+
+    parser.add_argument("-df","--downsampling_surface_face", help="lowers the resolution of the "
+                                                            "Fermi surface mesh (number of faces) to a given face number",
+                        default=None, type=int)
+
+
+    parser.add_argument("-c","--create_SVG", help="boolean whether to create SVG files ",
+                        action="store_true")
+
+    args = parser.parse_args()
+
+    # you can either parse a whole directory of .bxsf files or just the path to a single .bxsf file
+    file_list = []
+    if os.path.isfile(args.bxsf_files_directory):
+        file_list.append(os.path.basename(args.bxsf_files_directory))
+        path = os.path.abspath(os.path.dirname(args.bxsf_files_directory))
+        if args.save_fermisurfaces is not None:
+            save_path = args.save_fermisurfaces
+        else:
+            save_path = path
+    else:
+        file_list.extend(file_ for file_ in os.listdir(args.bxsf_files_directory) if file_.endswith('.bxsf'))
+        path = args.bxsf_files_directory
+        if args.save_fermisurfaces is not None:
+            save_path = args.save_fermisurfaces
+        else:
+            save_path = args.bxsf_files_directory
+
+    for filename in file_list:
+        filepath = os.path.join(path, filename)
+        # check if path leads to file
+        if not os.path.isfile(filepath):
+            continue
+
+        new_fermisurface = FermiSurface()
+
+        if args.subdivision_surface != 0 and args.downsampling_surface != 100:
+            raise ValueError("subdivision_surface and downsampling_surface are contrary functions")
+
+        new_fermisurface.build_surface_with_bxsf_files(filepath, args.subdivision_surface,
+                                                       args.downsampling_surface_percentage,
+                                                       args.downsampling_surface_face)
+
+        new_fermisurface.visualization(filepath, save_path, svg=args.create_SVG)
+
+if __name__ == "__main__":
+    main()

fsvisual/fermisurface.py

@@ -0,0 +1,251 @@
+from .input import read_energy_numbers
+from .brillouin_zone import first_bz
+from .visualisation import build_plotly_figure, write_figure_to_file
+from .mesh import create_cartesian_mesh, face_center_BZ
+from skimage import measure
+import numpy as np
+import trimesh
+import pymeshlab
+
+
+class FermiSurface:
+    """
+    Class for computing three-dimensional, interactive Fermi surfaces from .bxsf files, a filetype established by the
+    visualization software XCrsSDen. A Fermi surface is an object in k-space, that separates the occupied from the
+    unoccupied states (at the Fermi energy). Fermi surfaces are often shown within the first brillouin zone.
+
+    usage: If the Fermi surface data is present as a .bxsf file, which is widely adopted as an output for Fermi
+    surface calculations e.g. by Wannier90 or exciting, it is sufficient to just create an object of the FermiSurface
+    class and call the build_surface_with_bxsf_files method for building a Fermi surface. Afterwards the visualization
+    method can be called to create 3D interactive plots of the Fermi surface.
+
+    For information concerning the .bxsf file format, and also if your fermi surface data is stored in a different format,
+    please consult the documentation of FSvisual.
+    """
+
+    def __init__(self):
+        self.energy_values = None
+        self.fermi_energy = None
+        self.rez_base_vect = None
+        self.grid_size = None
+        self.brillouin_zone = None
+        self.surface = None
+        self.fermi_surface_list = None
+        self.band_index = None
+
+
+    @property
+    def cartesian_mesh(self):
+        return create_cartesian_mesh(self.grid_size)
+
+    def set_energy_values(self, energy_values):
+        self.energy_values = energy_values
+
+    def set_fermi_energy(self, fermi_energy):
+        self.fermi_energy = fermi_energy
+
+    def set_rez_base_vect(self, rez_base_vect):
+        self.rez_base_vect = rez_base_vect
+
+    def set_k_grid_by_size(self, grid_size):
+        self.grid_size = grid_size
+
+    def compute_brillouin_zone(self):
+        self.brillouin_zone = first_bz(self.rez_base_vect)
+
+    def marching_cubes(self, energyColumn):
+        grid_size = self.grid_size
+        new_basevect_grid_size = np.array([grid_size[0] * 2 - 1, grid_size[1] * 2 - 1, grid_size[2] * 2 - 1])
+
+        # creates an array with energies taken by the corresponding indices of new_cart_mesh_helper -> created array is
+        # as big as the indexing array
+        new_cart_mesh_helper = self.energy_values[energyColumn][self.cartesian_mesh.astype(int)]
+        new_cart_mesh_helper = np.array(new_cart_mesh_helper).reshape(
+            (new_basevect_grid_size[0], new_basevect_grid_size[1],
+             new_basevect_grid_size[2]))
+
+        # Apply the Marching Cubes algorithm
+        vertices, faces, normals, values = measure.marching_cubes(new_cart_mesh_helper, level=self.fermi_energy)
+
+        # coordinate transformation
+        new_basevect_mesh = np.dot(vertices, np.array(self.rez_base_vect))
+        ms = pymeshlab.MeshSet()
+        ms.add_mesh(pymeshlab.Mesh(new_basevect_mesh, faces))
+        new_mesh = ms.current_mesh()
+
+        self.surface = trimesh.Trimesh(vertices=np.asarray(new_mesh.vertex_matrix()),
+                                       faces=np.asarray(new_mesh.face_matrix()), process=False)
+
+        return self
+
+    def scale_surface(self, scale_factor):
+        """
+        Scales the Fermi surface according to the given `scale_factor`.
+        :param scale_factor: factor to scale the Fermi surface by
+        :return: self
+        """
+        if self.surface is None:
+            raise ValueError("surface is not yet defined")
+        # Create a scaling matrix
+        scaling_matrix = np.eye(4)
+        scaling_matrix[:3, :3] *= scale_factor
+
+        # Apply the scaling transformation to the mesh
+        self.surface.apply_transform(scaling_matrix)
+        return self
+
+    def center_surface(self):
+        """
+        centers the Fermi surface to the origin
+        :return: centered Fermi surface as Trimesh object
+        """
+        if self.surface is None:
+            raise ValueError("surface is not yet defined")
+
+        self.surface.apply_translation([-self.surface.centroid[i] for i in range(3)])
+        return self
+
+    def slice_surface(self):
+        """
+        Slices parts of the surface that extend beyond the brillouin zone
+        Note: Fermi surface needs to be centered and scaled according to the brillouin zone
+        :return: Sliced Fermi surface
+        """
+        if self.brillouin_zone is None:
+            raise ValueError("Brillouin Zone is not yet defined")
+        if self.surface is None:
+            raise ValueError("surface is not yet defined")
+
+        facet_centers = face_center_BZ(self.brillouin_zone[1])
+
+        # cutting off the surface area outside the 1. BZ
+        for i in range(len(self.brillouin_zone[1])):
+            facets_normal = np.array(facet_centers[i]) + 1 / 2 * np.array(facet_centers[i])
+
+            self.surface = self.surface.slice_plane(plane_origin=self.brillouin_zone[1][i][0],
+                                                    plane_normal=facets_normal * (-1))
+        return self
+
+    def subdivide_surface(self, iterations):
+        """
+        divides each triangle of the parsed triangle mesh in to two triangles and therefore
+        providing a higher resolution
+        :param iterations: how many times this algorithm is applied
+        :return: the higher resolution triangle mesh
+        """
+
+        if self.surface is None:
+            raise ValueError("surface is not yet defined")
+
+
+        vertices = self.surface.vertices
+        faces = self.surface.faces
+
+        ms = pymeshlab.MeshSet()
+
+        # Add it to the MeshSet
+        ms.add_mesh(pymeshlab.Mesh(vertex_matrix=vertices, face_matrix=faces))
+        ms.meshing_surface_subdivision_loop(iterations=iterations, threshold=pymeshlab.PercentageValue(0))
+
+        smoothed_mesh = ms.current_mesh()
+        self.surface = trimesh.Trimesh(vertices=np.asarray(smoothed_mesh.vertex_matrix()),
+                                        faces=np.asarray(smoothed_mesh.face_matrix()), process=False)
+
+        return self
+
+    def downsample_surface(self, face_percentage, face_numbers):
+        """
+        lowers the resolution of the Fermi surface mesh (number of faces) to a given percentage
+        (from original face count)
+        :param face_percentage: targeted face percentage
+        :return: self
+        """
+
+        if self.surface is None:
+            raise ValueError("surface is not yet defined")
+
+
+        if face_percentage == 100 and face_numbers is None:
+            return self
+        vertices = self.surface.vertices
+        faces = self.surface.faces
+
+        ms = pymeshlab.MeshSet()
+        # Add it to the MeshSet
+        ms.add_mesh(pymeshlab.Mesh(vertex_matrix=vertices, face_matrix=faces))
+
+        if face_numbers is not None and face_percentage != 100:
+            raise ValueError("You can only either provide a face_percentage or face_numbers, not both")
+        elif face_numbers is not None:
+            numFaces = face_numbers
+        else:
+            facenum = len(faces) * face_percentage / 100
+            numFaces = int(facenum)
+
+        ms.meshing_decimation_quadric_edge_collapse(targetfacenum=numFaces)
+
+        smoothed_mesh = ms.current_mesh()
+        self.surface = trimesh.Trimesh(vertices=np.asarray(smoothed_mesh.vertex_matrix()),
+                                        faces=np.asarray(smoothed_mesh.face_matrix()), process=False)
+
+        return self
+
+    def build_surface_with_bxsf_files(self, filepath, subdivide_iterations=0, down_sampling_percentage=100,
+                                      downsampling_surface_face=None):
+        """
+        whole fermi surface construction process for bxsf files, including reading out the input data, building the
+        first brillouin zone and applying the marching cubes' algorithm.
+        :param filepath: path to bxsf file.
+        :param subdivide_iterations: number of iterations to subdivide the Fermi surface by subdivide_surface
+        :param down_sampling_percentage: percentage to which the downsampling_surface method reduces the number of faces
+        :param downsampling_surface_face: number of faces to which the downsampling_surface method reduces the mesh
+        :return: self
+        """
+
+        data = read_energy_numbers(filepath)
+        self.set_energy_values(data[0])
+        self.set_fermi_energy(data[1])
+        self.set_rez_base_vect(data[2])
+        self.set_k_grid_by_size(data[3])
+
+        self.compute_brillouin_zone()
+
+        grid_size = self.grid_size
+        new_basevect_grid_size = np.array([grid_size[0] * 2 - 1, grid_size[1] * 2 - 1, grid_size[2] * 2 - 1])
+
+        self.band_index = []
+        self.fermi_surface_list = []
+        for index, columnName in enumerate(self.energy_values.columns):
+
+            # Apply the Marching Cubes algorithm
+            try:
+                self.marching_cubes(columnName)
+            except ValueError:
+                continue
+
+
+            self.subdivide_surface(subdivide_iterations)
+            self.downsample_surface(face_percentage=down_sampling_percentage,face_numbers=downsampling_surface_face)
+
+            # translation and shrinkage
+            self.scale_surface(2 / new_basevect_grid_size)
+
+            # translation
+            self.center_surface()
+
+            self.slice_surface()
+
+            self.fermi_surface_list.append(self.surface)
+            self.band_index.append(index + 1)  # for the plot
+        return self
+
+    def visualization(self, filepath, save_fermisurf_path, svg=False):
+        """
+        Visualizes the Fermi surface as a 3D interactive plot saved as an html file. Also allows for creating
+        an SVG Image of the Fermi surface along the html file.
+        :param filepath: path to bxsf file.
+        :param save_fermisurf_path: directory where the created files and imaged will be stored
+        :param svg: boolean whether to create the SVG image
+        """
+        figure = build_plotly_figure(self.fermi_surface_list, self.brillouin_zone, self.band_index)
+        write_figure_to_file(figure, filepath, save_fermisurf_path, create_SVG=svg)

fsvisual/input.py

@@ -0,0 +1,52 @@
+import pandas as pd
+
+
+# Define a function to process the text file
+def read_energy_numbers(filepath):
+    """
+    function that extracts all necessary data out of the FERMISURF.bxsf file
+    :param filepath: path of the FERMISURF.bxsf file
+    :return: energy DataFrame, fermi energy, reciprocal base vectors, grid size
+    """
+
+    with open(filepath, 'r') as file:
+        lines = file.readlines()
+
+    # Filter out the lines containing energy numbers
+
+    values_in_series = []
+    my_dict = {}
+    fermi_energy = 0
+    rez_base_vect = []
+    grid_size = []
+    j = 0
+    for i, line in enumerate(lines):
+        if i == 3:  # fermi_energy
+            fermi_energy = float(line[19:31])
+        if i == 9:  # grid_size
+            grid = line.split(" ")
+            grid = [int(num) for num in grid if num != "" and num != "\n"]
+            grid_size.append(grid)
+
+        if 10 < i < 14:  # base vectors
+            vect = [line.split(" ")]
+            vect[0] = [float(num) for num in vect[0] if num != "" and num != "\n"]
+            rez_base_vect.extend(vect)
+        if i >= 13:  # algorythm that collects all the energies and stores them into separate bands
+            if line.startswith(" BAND"):
+                if j == 0:
+                    pass
+                else:
+                    my_dict[f"Band {j}"] = values_in_series
+                    values_in_series = []
+                j += 1
+            try:
+                energy = float(line.strip())
+                values_in_series.append(energy)
+            except ValueError:
+                pass  # Ignore lines that cannot be converted to float
+
+        i += 1
+    my_dict[f"Band {j}"] = values_in_series
+    df = pd.DataFrame(my_dict)
+    return df, fermi_energy, rez_base_vect, grid_size[0]

fsvisual/mesh.py

@@ -0,0 +1,134 @@
+import numpy as np
+
+
+def create_cartesian_mesh(grid_size):
+    """
+    creates a mesh within the reciprocal unit cell for any reciprocal lattice
+    :param grid_size: number of datapoints the grid should have (list of 3 number for each lattice vector)
+    :return: standard mesh
+    """
+
+    grid_size = [int(grid_size_n) for grid_size_n in grid_size]
+    Imin = [0] * 3
+    Imax = [0] * 3
+
+    # loop that creates the mesh
+
+    band_grid = np.arange((grid_size[0]) * (grid_size[1]) * (grid_size[2]))
+    band_grid = band_grid.reshape((grid_size[0], grid_size[1], grid_size[2]))
+
+    grid_size_minus_one = [grid - 1 for grid in grid_size]
+
+    for k in range(3):
+        Imin[k] = -int(grid_size_minus_one[k])
+        Imax[k] = int(grid_size_minus_one[k])
+
+    # creating the mols
+    mesh_axis_one = np.arange(Imin[0], Imax[0] + 1)
+    mesh_axis_two = np.arange(Imin[1], Imax[1] + 1)
+    mesh_axis_three = np.arange(Imin[2], Imax[2] + 1)
+
+    mesh_axis_one = np.where(mesh_axis_one >= 0, mesh_axis_one, mesh_axis_one + grid_size_minus_one[0])
+    mesh_axis_two = np.where(mesh_axis_two >= 0, mesh_axis_two, mesh_axis_two + grid_size_minus_one[1])
+    mesh_axis_three = np.where(mesh_axis_three >= 0, mesh_axis_three, mesh_axis_three + grid_size_minus_one[2])
+
+    index_mesh = np.ix_(mesh_axis_one, mesh_axis_two, mesh_axis_three)
+
+    cartesian_mesh = band_grid[index_mesh].flatten()
+
+    return cartesian_mesh
+
+
+def triangulate_faces(facets):
+    """
+    splits every facet of the 1. BZ into triangles for Trimesh to read -> function is used by brillouin_intersect_mesh()
+    :param facets: list of all facets with vertices counted from 0 to last vertex
+    :return:
+    """
+    triangles = []
+    for facet in facets:
+        if len(facet) == 3:
+            triangles.append(facet)
+        elif len(facet) == 4:
+            triangles.append([facet[0], facet[1], facet[2]])
+            triangles.append([facet[0], facet[2], facet[3]])
+        else:
+            # For facets with more than 4 vertices, use a fan triangulation
+            for i in range(1, len(facet) - 1):
+                triangles.append([facet[0], facet[i], facet[i + 1]])
+    return triangles
+
+
+def abs_vect(vector):
+    """
+    :param vector: takes 3D vector as a list or array
+    :return: absolute value of that vector
+    """
+    return np.sqrt(vector[0] ** 2 + vector[1] ** 2 + vector[2] ** 2)
+
+
+def triangle_area(triangle):
+    """
+    calculates the area of a triangle via vertices
+    :param triangle: list of 3 3D vertices
+    :return: area of a triangle in FE
+    """
+
+    # from coordinates in space
+
+    P1 = np.array(triangle[0])
+    P2 = np.array(triangle[1])
+    P3 = np.array(triangle[2])
+
+    area = 1 / 2 * np.sqrt(abs_vect(P2 - P1) ** 2 * abs_vect(P3 - P1) ** 2 - np.dot((P2 - P1), (P3 - P1)) ** 2)
+    return area
+
+
+def triangle_center(triangle):
+    """
+    calculates the center of every triangle
+    :param triangle: list of 3 vertices
+    :return: center point of a triangle
+    """
+
+    xS = 1 / 3 * (triangle[0][0] + triangle[1][0] + triangle[2][0])
+    yS = 1 / 3 * (triangle[0][1] + triangle[1][1] + triangle[2][1])
+    zS = 1 / 3 * (triangle[0][2] + triangle[1][2] + triangle[2][2])
+
+    return [xS, yS, zS]
+
+
+def face_center_BZ(brillouin_zone_facets):
+    """
+    function to calculate the center of every facet
+    :param brillouin_zone_facets: list with all facets (filled with points, not indices)
+    :return: list of 3D center points for every facet
+    """
+
+    # triangulate the facets:
+    triangle_list = triangulate_faces(brillouin_zone_facets)
+
+    face_centers = []
+    j = 0
+    for facet in brillouin_zone_facets:  # goes through every facet and calculates the center of it
+        triangle_areas = []
+        triangle_centers = []
+        for triangle in triangle_list[j:j + len(facet) - 2]:  # goes through every triangle of each facet
+            # triangle area:
+            if triangle_area(triangle) != 0:
+                triangle_areas.append(triangle_area(triangle))  # triangle area
+                triangle_centers.append(triangle_center(triangle))  # triangle center
+        j += len(facet) - 2
+
+        x_coord = np.array([point[0] for point in triangle_centers])
+        y_coord = np.array([point[1] for point in triangle_centers])
+        z_coord = np.array([point[2] for point in triangle_centers])
+
+        # calculation of the facet center (geometrischer Schwerpunkt)
+        xS = np.sum(x_coord * np.array(triangle_areas)) / np.sum(triangle_areas)
+        yS = np.sum(y_coord * np.array(triangle_areas)) / np.sum(triangle_areas)
+        zS = np.sum(z_coord * np.array(triangle_areas)) / np.sum(triangle_areas)
+
+        face_centers.append([xS, yS, zS])
+
+    return face_centers

fsvisual/visualisation.py

@@ -0,0 +1,126 @@
+import numpy as np
+import plotly.graph_objects as go
+import plotly.io as pio
+import os
+import kaleido
+
+
+def build_plotly_figure(fermi_surface_list, brillouin_zone_object, band_index):
+    """
+    to build the Fermi surface as a 3D interactive plotly figure
+    :param fermi_surface_list: list of all surface parts of the Fermi surface
+    :param brillouin_zone_object: the brillouin zone object created with the compute_brillouin_zone from FSvisual
+    :param band_index: list of band indices corresponding to each surface part
+    :return: the plotly figure
+    """
+    mesh_fermi_surfaces = []
+    for index, fermi_surface in enumerate(fermi_surface_list):
+        x_mesh, y_mesh, z_mesh = fermi_surface.vertices[:, 0], fermi_surface.vertices[:, 1], fermi_surface.vertices[:,
+                                                                                             2]
+
+        # Extract I, J, K indices of faces
+        i, j, k = fermi_surface.faces[:, 0], fermi_surface.faces[:, 1], fermi_surface.faces[:, 2]
+
+        mesh_fermi_surfaces.append(go.Mesh3d(
+            x=np.array(x_mesh),
+            y=np.array(y_mesh),
+            z=np.array(z_mesh),
+            i=np.array(i),
+            j=np.array(j),
+            k=np.array(k),
+            name=f"Band {band_index[index]}",
+            opacity=1,
+            showlegend=True
+        ))
+
+    x = brillouin_zone_object[0][0]
+    y = brillouin_zone_object[0][1]
+    z = brillouin_zone_object[0][2]
+
+    # find highest and lowest point of BZ for axis scaling:
+
+    # filter non values and find maximum on each axis
+    max_x = np.max([np.abs(num) for num in x if num is not None])
+    max_y = np.max([np.abs(num) for num in y if num is not None])
+    max_z = np.max([np.abs(num) for num in z if num is not None])
+
+    # calculate global maximum
+    max_value_axis = np.max([max_x, max_y, max_z])
+
+
+    if max_value_axis > 0:
+        max_value_axis += 1/10*max_value_axis
+    else:
+        max_value_axis -= 1/10*max_value_axis
+
+
+    # Create a 3D scatter plot
+    scatter_BZ = go.Scatter3d(
+        x=x,
+        y=y,
+        z=z,
+        mode='lines',
+        name="1. BZ",
+        line=dict(color='black', width=6)
+    )
+
+    # contains all
+    fig_data = [scatter_BZ]
+    fig_data.extend(mesh_fermi_surfaces)
+
+    fig = go.Figure(data=fig_data)
+
+    fig.update_layout(
+
+        scene=dict(
+            xaxis=dict(
+                range=[-max_value_axis, max_value_axis],  # Fester Bereich für x-Achse
+                visible=False
+            ),
+            yaxis=dict(
+                range=[-max_value_axis, max_value_axis],  # Fester Bereich für y-Achse
+                visible=False
+            ),
+            zaxis=dict(
+                range=[-max_value_axis, max_value_axis],  # Fester Bereich für z-Achse
+                visible=False
+            ),
+            annotations=[],  # Remove any annotations if present
+            aspectmode='cube',
+            camera=dict(
+                projection=dict(
+                    type='orthographic'
+                    # to change the perspective (so that lines don't distort over distance)
+                )
+            )
+        )
+    )
+    return fig
+
+
+def write_figure_to_file(fig, filepath, save_figure_directory, create_SVG=True,
+                         scene_camera_SVG=None):
+    """
+    Function to take a plotly figure and write it to a file with potentially also creating an SVG file.
+    :param fig: plotly figure
+    :param filepath: path to .bxsf file/files
+    :param save_figure_directory: directory where to save the figure
+    :param create_SVG: boolean whether to create SVG file
+    :param scene_camera_SVG: alter the cameras position and angle with dictionary (scene_camera parameter in plotly)
+    """
+
+    filename = os.path.basename(filepath)
+    filename = filename.split(".")[0]
+    pio.write_html(fig, file=f'{save_figure_directory}/{filename}.html', auto_open=False,
+                   config={'displayModeBar': False})
+
+    if create_SVG:
+        kaleido.get_chrome_sync()
+        if scene_camera_SVG is None:
+            scene_camera_SVG = dict(eye=dict(x=1, y=1, z=1))
+        fig.update_layout(
+            showlegend=False,
+            scene_camera=scene_camera_SVG,  # change camera scene
+            margin=dict(l=0, r=0, b=0, t=0)  # set the space on the edges to 0 (so that the plot fills out the image)
+        )
+        fig.write_image(f'{save_figure_directory}/{filename}.svg', format="svg", width=500, height=800)