pyphyschemtools 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

pyphyschemtools/.ipynb_checkpoints/PeriodicTable-checkpoint.py

@@ -0,0 +1,294 @@
+############################################################
+#                       Periodic Table
+############################################################
+from .visualID_Eng import fg, bg, hl
+from .core import centerTitle, centertxt
+
+import mendeleev
+
+class TableauPeriodique:
+    nomsFr=['Hydrogène','Hélium','Lithium','Béryllium','Bore','Carbone','Azote','Oxygène',
+            'Fluor','Néon','Sodium','Magnésium','Aluminium','Silicium','Phosphore','Soufre',
+            'Chlore','Argon','Potassium','Calcium','Scandium','Titane','Vanadium','Chrome',
+            'Manganèse','Fer','Cobalt','Nickel','Cuivre','Zinc','Gallium','Germanium',
+            'Arsenic','Sélénium','Brome','Krypton','Rubidium','Strontium','Yttrium',
+            'Zirconium','Niobium','Molybdène','Technétium','Ruthénium','Rhodium',
+            'Palladium','Argent','Cadmium','Indium',
+            'Étain','Antimoine','Tellure','Iode','Xénon','Césium','Baryum','Lanthane','Cérium',
+            'Praséodyme','Néodyme','Prométhium','Samarium','Europium','Gadolinium','Terbium',
+            'Dysprosium','Holmium','Erbium','Thulium','Ytterbium','Lutetium','Hafnium','Tantale',
+            'Tungstène','Rhénium','Osmium','Iridium','Platine','Or','Mercure','Thallium','Plomb',
+            'Bismuth','Polonium','Astate','Radon','Francium','Radium','Actinium','Thorium','Protactinium',
+            'Uranium','Neptunium','Plutonium','Americium','Curium','Berkelium','Californium','Einsteinium',
+            'Fermium','Mendelevium','Nobelium','Lawrencium','Rutherfordium','Dubnium','Seaborgium','Bohrium',
+            'Hassium','Meitnerium','Darmstadtium','Roentgenium','Copernicium','Nihonium','Flerovium',
+            'Moscovium','Livermorium','Tennesse','Oganesson',
+            ]
+    trad = {'Nonmetals':'Non métal',
+            'Noble gases':'Gaz noble',
+            'Alkali metals':'Métal alcalin',
+            'Alkaline earth metals':'Métal alcalino-terreux',
+            'Metalloids':'Métalloïde',
+            'Halogens':'Halogène',
+            'Poor metals':'Métal pauvre',
+            'Transition metals':'Métal de transition',
+            'Lanthanides':'Lanthanide',
+            'Actinides':'Actinide',
+            'Metals':'Métal',
+           }
+
+    def __init__(self):
+        from mendeleev.vis import create_vis_dataframe
+        self.elements = create_vis_dataframe()
+        self.patch_elements()
+
+    def patch_elements(self):
+        '''
+        Ce patch, appliqué à self.elements, créé par l'appel à create_vis_dataframe(), va servir à :
+        - ajouter des informations en français : les noms des éléments et des séries (familles) auxquelles ils appartiennent
+        - retirer les éléments du groupe 12 de la famille des métaux de transition, qui est le choix CONTESTABLE par défaut de la bibliothèque mendeleev
+        
+        input :
+        elements est un dataframe pandas préalablement créé par la fonction create_vis_dataframe() de mendeleev.vis
+        
+        output :
+        elements avec deux nouvelles colonnes name_seriesFr et nom, qui contient dorénavant les noms des éléments en français
+        + correction des données name_series et series_id pour les éléments Zn, Cd, Hg, Cn
+        + de nouvelles colonnes qui contiennent l'énergie de première ionisation et les isotopes naturels
+                        
+        '''
+        def series_eng2fr(s):
+            '''Correspondance entre nom des séries (familles) en anglais et en français'''
+            s = TableauPeriodique.trad[s]
+            return s
+
+        def name_eng2fr():
+            self.elements["nom"] = TableauPeriodique.nomsFr
+            return
+
+        def ajouter_donnees():
+            import numpy as np
+            from mendeleev.fetch import fetch_table, fetch_ionization_energies
+            import pandas as pd
+            # dfElts = fetch_table("elements")
+            # display(dfElts)
+            dfEi1 = fetch_ionization_energies(degree = 1)
+            # display(dfEi1)
+            b = pd.DataFrame({'atomic_number':[x for x in range(1, 119)]})
+            dfEi1tot = pd.merge(left=dfEi1, right=b, on='atomic_number', how='outer').sort_values(by='atomic_number')
+            self.elements["Ei1"] = dfEi1tot["IE1"]
+        
+        # les éléments du groupe 12 ne sont pas des métaux de transition
+        self.elements.loc[29,"name_series"] = 'Metals'
+        self.elements.loc[47,"name_series"] = 'Metals'
+        self.elements.loc[79,"name_series"] = 'Metals'
+        self.elements.loc[111,"name_series"] = 'Metals'
+        self.elements.loc[29,"series_id"] = 11
+        self.elements.loc[47,"series_id"] = 11
+        self.elements.loc[79,"series_id"] = 11
+        self.elements.loc[111,"series_id"] = 11
+        self.elements.loc[29,"color"] = "#bbd3a5"
+        self.elements.loc[47,"color"] =  "#bbd3a5"
+        self.elements.loc[79,"color"] =  "#bbd3a5"
+        self.elements.loc[111,"color"] =  "#bbd3a5"
+        # english > français. Ajout d'une nouvelle colonne 
+        self.elements["name_seriesFr"] = self.elements["name_series"].apply(series_eng2fr)
+        # english > français. Noms des éléments en français changés dans la colonne name
+        name_eng2fr()
+        ajouter_donnees()
+        return
+
+    def prop(self,elt_id):
+        from mendeleev import element
+
+        elt = element(elt_id)
+        print(f"Nom de l'élement = {TableauPeriodique.nomsFr[elt.atomic_number-1]} ({elt.symbol}, Z = {elt.atomic_number})")
+        print(f"Nom en anglais = {elt.name}")
+        print(f"Origine du nom = {elt.name_origin}")
+        print()
+        print(f"CEF = {elt.ec} = {elt.econf}")
+        print(f"Nombre d'électrons célibataires = {elt.ec.unpaired_electrons()}")    
+        print(f"Groupe {elt.group_id}, Période {elt.period}, bloc {elt.block}")
+        print(f"Famille = {self.elements.loc[elt.atomic_number-1,'name_seriesFr']}")
+        print()
+        print(f"Masse molaire = {elt.atomic_weight} g/mol")
+        isotopes = ""
+        X = elt.symbol
+        for i in elt.isotopes:
+            if i.abundance is not None:
+                isotopes = isotopes + str(i.mass_number)+ "^" + X + f"({i.abundance}%) / "
+        print("Isotopes naturels = ",isotopes[:-2])
+        print()
+        if elt.electronegativity(scale='pauling') is None:
+            print(f"Électronégativité de Pauling = Non définie")
+        else:
+            print(f"Électronégativité de Pauling = {elt.electronegativity(scale='pauling')}")
+        print(f"Énergie de 1ère ionisation = {elt.ionenergies[1]:.2f} eV")
+        if elt.electron_affinity is None:
+            print(f"Affinité électronique = Non définie")
+        else:
+            print(f"Afinité électronique = {elt.electron_affinity:.2f} eV")
+        print(f"Rayon atomique = {elt.atomic_radius:.1f} pm")
+        print()
+        print("▶ Description : ",elt.description)
+        print("▶ Sources : ",elt.sources)
+        print("▶ Utilisation : ",elt.uses)
+        print("---------------------------------------------------------------------------------------")
+        print()
+
+    def afficher(self):
+        from bokeh.plotting import show, output_notebook
+        from mendeleev.vis import periodic_table_bokeh
+        
+        # Toute cette partie du code est une copie du module bokeh de mendeleev.vis
+        # La fonction periodic_table_bokeh étant faiblement configurable avec des args/kwargs,
+        # elle est adaptée ici pour un affichage personnalisé
+        
+        from collections import OrderedDict
+        
+        import pandas as pd
+        from pandas.api.types import is_float_dtype
+        
+        from bokeh.plotting import figure
+        from bokeh.models import HoverTool, ColumnDataSource, FixedTicker
+        
+        from mendeleev.vis.utils import colormap_column
+        
+        
+        def periodic_table_bokeh(
+            elements: pd.DataFrame,
+            attribute: str = "atomic_weight",
+            cmap: str = "RdBu_r",
+            colorby: str = "color",
+            decimals: int = 3,
+            height: int = 800,
+            missing: str = "#ffffff",
+            title: str = "Periodic Table",
+            wide_layout: bool = False,
+            width: int = 1200,
+        ):
+            """
+            Use Bokeh backend to plot the periodic table. Adaptation by Romuald Poteau (romuald.poteau@univ-tlse3.fr) of the orignal periodic_table_bokeh() function of the mendeleev library
+        
+            Args:
+                elements : Pandas DataFrame with the elements data. Needs to have `x` and `y`
+                    columns with coordianates for each tile.
+                attribute : Name of the attribute to be displayed
+                cmap : Colormap to use, see matplotlib colormaps
+                colorby : Name of the column containig the colors
+                decimals : Number of decimals to be displayed in the bottom row of each cell
+                height : Height of the figure in pixels
+                missing : Hex code of the color to be used for the missing values
+                title : Title to appear above the periodic table
+                wide_layout: wide layout variant of the periodic table
+                width : Width of the figure in pixels
+            """
+        
+            if any(col not in elements.columns for col in ["x", "y"]):
+                raise ValueError(
+                    "Coordinate columns named 'x' and 'y' are required "
+                    "in 'elements' DataFrame. Consider using "
+                    "'mendeleev.vis.utils.create_vis_dataframe' and try again."
+                )
+        
+            # additional columns for positioning of the text
+        
+            elements.loc[:, "y_anumber"] = elements["y"] - 0.3
+            elements.loc[:, "y_name"] = elements["y"] + 0.2
+        
+            if attribute:
+                elements.loc[elements[attribute].notnull(), "y_prop"] = (
+                    elements.loc[elements[attribute].notnull(), "y"] + 0.35
+                )
+            else:
+                elements.loc[:, "y_prop"] = elements["y"] + 0.35
+        
+            ac = "display_attribute"
+            if is_float_dtype(elements[attribute]):
+                elements[ac] = elements[attribute].round(decimals=decimals)
+            else:
+                elements[ac] = elements[attribute]
+        
+            if colorby == "attribute":
+                colored = colormap_column(elements, attribute, cmap=cmap, missing=missing)
+                elements.loc[:, "attribute_color"] = colored
+                colorby = "attribute_color"
+        
+            # bokeh configuration
+        
+            source = ColumnDataSource(data=elements)
+        
+            TOOLS = "hover,save,reset"
+        
+            fig = figure(
+                title=title,
+                tools=TOOLS,
+                x_axis_location="above",
+                x_range=(elements.x.min() - 0.5, elements.x.max() + 0.5),
+                y_range=(elements.y.max() + 0.5, elements.y.min() - 0.5),
+                width=width,
+                height=height,
+                toolbar_location="above",
+                toolbar_sticky=False,
+            )
+        
+            fig.rect("x", "y", 0.9, 0.9, source=source, color=colorby, fill_alpha=0.6)
+        
+            # adjust the ticks and axis bounds
+            fig.yaxis.bounds = (1, 7)
+            fig.axis[1].ticker.num_minor_ticks = 0
+            if wide_layout:
+                # Turn off tick labels
+                fig.axis[0].major_label_text_font_size = "0pt"
+                # Turn off tick marks
+                fig.axis[0].major_tick_line_color = None  # turn off major ticks
+                fig.axis[0].ticker.num_minor_ticks = 0  # turn off minor ticks
+            else:
+                fig.axis[0].ticker = FixedTicker(ticks=list(range(1, 19)))
+        
+            text_props = {
+                "source": source,
+                "angle": 0,
+                "color": "black",
+                "text_align": "center",
+                "text_baseline": "middle",
+            }
+        
+            fig.text(
+                x="x",
+                y="y",
+                text="symbol",
+                text_font_style="bold",
+                text_font_size="15pt",
+                **text_props,
+            )
+            fig.text(
+                x="x", y="y_anumber", text="atomic_number", text_font_size="9pt", **text_props
+            )
+            fig.text(x="x", y="y_name", text="name", text_font_size="6pt", **text_props)
+            fig.text(x="x", y="y_prop", text=ac, text_font_size="7pt", **text_props)
+        
+            fig.grid.grid_line_color = None
+        
+            hover = fig.select(dict(type=HoverTool))
+            hover.tooltips = OrderedDict(
+                [
+                    ("nom", "@nom"),
+                    ("name", "@name"),
+                    ("famille", "@name_seriesFr"),
+                    ("numéro atomique", "@atomic_number"),
+                    ("masse molaire", "@atomic_weight"),
+                    ("rayon atomique", "@atomic_radius"),
+                    ("énergie de première ionisation", "@Ei1"),
+                    ("affinité électronique", "@electron_affinity"),
+                    ("EN Pauling", "@en_pauling"),
+                    ("CEF", "@electronic_configuration"),
+                ]
+            )
+        
+            return fig
+
+        output_notebook()
+
+        fig = periodic_table_bokeh(self.elements, colorby="color")
+        show(fig)

pyphyschemtools/.ipynb_checkpoints/aithermo-checkpoint.py

@@ -0,0 +1,349 @@
+import os
+import sys
+import glob
+import numpy as np
+from pathlib import Path
+from PIL import Image, ImageOps
+import plotly.graph_objects as go
+import plotly.io as pio
+import seaborn as sns
+from matplotlib import pyplot as plt
+
+class aiThermo:
+    """
+    A class to handle thermodynamic surface stability analysis and visualization
+    within the tools4pyPhysChem framework.
+    """
+
+    def __init__(self, folder_path=None, color_scales=None):
+        """
+        Initialize the aiThermo object.
+
+        Args:
+            folder_path (str or Path): Path to the working directory.
+            color_scales (list, optional): List of plotly-compatible color scales.
+        """
+        self.folder_path = Path(folder_path) if folder_path else None
+        self.color_scales = color_scales or [
+            [[0, "#dadada"], [1, "#dadada"]], [[0, "#99daaf"], [1, "#99daaf"]],
+            [[0, "#f1aeaf"], [1, "#f1aeaf"]], [[0, "#81bbda"], [1, "#81bbda"]],
+            [[0, "#da9ac9"], [1, "#da9ac9"]], [[0, "#79dad7"], [1, "#79dad7"]],
+            [[0, "#da9f6e"], [1, "#da9f6e"]], [[0, "#b5a8da"], [1, "#b5a8da"]],
+            [[0, "#edf1c6"], [1, "#edf1c6"]], [[0, "#c4ffe3"], [1, "#c4ffe3"]],
+            [[0, "#61b3ff"], [1, "#61b3ff"]]
+        ]
+        self.palette = [c[0][1] for c in self.color_scales]
+    def _check_folder(self):
+        """Internal check to ensure folder_path is set before file operations."""
+        if self.folder_path is None:
+            raise ValueError(
+                "❌ Error: folder_path is not defined for this instance. "
+                "Please provide a path when initializing: aiThermo(folder_path='...')"
+            )
+        if not self.folder_path.exists():
+             raise FileNotFoundError(f"❌ Error: The directory {self.folder_path} does not exist.")
+            
+    def ListOfStableSurfaceCompositions(self, vib):
+        """
+        Identify and list the relevant thermodynamic data files for the current analysis.
+
+        This method scans the working directory for data files matching specific 
+        naming conventions (TPcoverage or TPcoveragevib). It cross-references 
+        these with a local configuration file 'ListOfStableSurfaces.dat' to 
+        extract surface names and legend labels.
+
+        Args:
+            vib (bool): If True, filters for files including vibrational corrections (prefixed with ``vib_``). If False, looks for standard thermodynamic data.
+
+        Returns:
+            tuple: A triplet containing:
+            - file_paths (list of str): Absolute or relative paths to the .dat files.
+            - names (list of str): Internal identifiers for each surface phase.
+            - legends (list of str): LaTeX-formatted or plain text labels for graphical legends.
+
+        Notes:
+            - The lists are returned in reverse order to ensure correct layering 
+              during 3D plotting.
+            - Relies on 'ListOfStableSurfaces.dat' existing in the folder_path.
+            
+        """
+        self._check_folder()
+        from .core import centertxt
+        import glob
+        pattern = "TPcoveragevib_*.dat" if vib else "TPcoverage_*.dat"
+        file_paths = glob.glob(str(self.folder_path / pattern))
+        listOfMinCov = self.folder_path / "ListOfStableSurfaces.dat"
+        print(f"List of Stable surfaces is in: {listOfMinCov}")
+        # if vib:
+        #     file_paths = glob.glob(os.path.join(self.folder_path, "TPcoveragevib_*.dat"))
+        # else:
+        #     file_paths = glob.glob(os.path.join(self.folder_path, "TPcoverage_*.dat"))
+        # print(vib,file_paths)
+        # listOfMinCov = os.path.join(self.folder_path, "ListOfStableSurfaces.dat")
+        # print("list of Stable surfaces is in: ",listOfMinCov)
+        try:
+            with open(listOfMinCov, "r") as f:
+                lines = [line.rstrip('\n').split() for line in f]
+        
+            file_paths = []
+            names = []
+            legends = []
+            for l in lines:
+                # file_paths = file_paths + glob.glob(os.path.join(self.folder_path, l[0]))
+                file_paths = file_paths + glob.glob(str(self.folder_path / l[0]))
+                names = names + [l[1]]
+                # legends = legends + [l[2]]
+                legends.append(fr"{l[2]}") # The 'fr' ensures it is a Raw Formatted string
+            names = names[::-1]
+            legends = legends[::-1]
+            file_paths = file_paths[::-1]
+            centertxt(f"List of stable surface compositions. Vibrations = {vib}",size=14,weight="bold") 
+            if not vib:
+                file_paths = [f.replace('vib_', '_') for f in file_paths]
+            for i,f in enumerate(file_paths):
+                print(f"{f}  {names[i]}    {legends[i]}")
+    
+        except FileNotFoundError:
+            print(f"ListOfStableSurfaces.dat file has not been found in the {self.folder_path} folder. Exiting...")
+            sys.exit()
+        return file_paths,names,legends
+    
+    def plot_surface(self, saveFig=None, vib=True, texLegend=False, xLegend=0.5, yLegend=0.4):
+        """
+        Generate an interactive 3D thermodynamic stability map using Plotly.
+
+        This method visualizes multiple Gibbs free energy surfaces as a function of 
+        Temperature (X) and Pressure (Y). It automatically handles log-scale 
+        transformations for the pressure axis and projects reference experimental 
+        conditions and phase boundaries onto the plot.
+
+        Args:
+            saveFig (str, optional): The filename (without extension) to export 
+                the resulting plot as a PNG image. Defaults to None (no save).
+            vib (bool): Whether to use vibration-corrected data. Defaults to True.
+            texLegend (bool): If True, uses LaTeX legends extracted from the 
+                configuration file. Defaults to False.
+            xLegend (float): Horizontal position of the legend box (0 to 1). 
+                Defaults to 0.5.
+            yLegend (float): Vertical position of the legend box (0 to 1). 
+                Defaults to 0.4.
+
+        Returns:
+            plotly.graph_objects.FigureWidget: An interactive widget containing 
+                the 3D surfaces, experimental markers, and reference lines.
+
+        Workflow:
+            1. Scans data files and parses Temperature/Pressure/Energy grids.
+            2. Traces individual 3D surfaces with mapped color scales.
+            3. Calculates and plots intersection boundaries between surface phases.
+            4. Overlays experimental markers (e.g., specific T/P conditions).
+            5. Optionally exports and crops the resulting image using Pillow.
+        """
+        self._check_folder()
+        import os
+        # Define tick values explicitly for log scale (powers of 10)
+        color_scales = self.color_scales
+        logmin = -20
+        logmax = 5
+        log_tick_vals = np.logspace(logmin, logmax, num=1+(logmax-logmin)//5)  # Example range from 10^20 to 10^5
+        log_tick_labels = [f"10<sup>{int(np.log10(tick))}</sup>" for tick in log_tick_vals]  # Format labels as 10^n
+        import plotly.graph_objects as go
+        
+        stableSurfaces, nameOfStableSurfaces, legendOfStableSurfaces = self.ListOfStableSurfaceCompositions(vib)
+
+        # FIX: Track all Z values to find a true global minimum for the floor
+        all_z_mins = []
+        
+        fig = go.Figure()
+        
+        for i, file_path in enumerate(stableSurfaces):
+            with open(file_path, "r") as f:
+                lines = f.readlines()
+        
+            series = []
+            temp = []
+            for line in lines:
+                if line.strip():  
+                    temp.append(list(map(float, line.split())))  
+                else:
+                    if temp:
+                        series.append(np.array(temp)) 
+                        temp = []
+            if temp: 
+                series.append(np.array(temp))
+        
+            data = np.array(series)
+        
+            X = data[:, :, 0]
+            Y = data[:, :, 1]
+            Z = data[:, :, 2]
+            all_z_mins.append(np.min(Z))
+        
+            fig.add_trace(go.Surface(
+                x=X, 
+                y=Y,
+                z=Z, 
+                colorscale=color_scales[i % len(color_scales)],  
+                showscale=False,
+                name = nameOfStableSurfaces[i]))
+        
+            if legendOfStableSurfaces[i] != "None" and texLegend:
+                name=f"{legendOfStableSurfaces[i]}"
+            else:
+                name=f"{nameOfStableSurfaces[i]}"
+            fig.add_trace(go.Scatter3d(
+                x=[None], y=[None], z=[None],  # Invisible point
+                mode="markers",
+                name=f"{name}",
+                marker=dict(color=color_scales[i % len(color_scales)][-1][1], size=10),
+                showlegend=True))
+    
+        # FIX: Calculate zmin globally
+        zmin = np.min(all_z_mins) - 50
+
+        fig.add_trace(go.Scatter3d(
+            x=[55+273.15,90+273.15], y=[np.log10(2),np.log10(4)], z=[zmin-10,zmin-10],  # Invisible point
+            mode="markers",
+            marker=dict(color='red', size=10, symbol='cross'),
+            name='exp. Conditions (55°C, 2 bar & 90°C, 4 bar)',
+            showlegend=True))
+        
+        fig.add_trace(go.Scatter3d(
+            x=[0, 1000], y=[np.log10(1),np.log10(1)], z=[zmin+600]*2,
+            mode="lines",
+            line=dict(color="blue", width=3),
+            name="1 bar",
+            showlegend=False
+        ))        
+        
+        fig.add_trace(go.Scatter3d(
+            x=[298, 298], y=[-20,5], z=[zmin+600]*2,
+            mode="lines",
+            line=dict(color="black", width=3),
+            name="298 K",
+            showlegend=False
+        ))        
+            
+                
+        fig.update_layout(
+            width=1200,  # Increase figure width (default is ~700)
+            height=1200,
+            paper_bgcolor='rgba(0,0,0,0)',  # White background outside the plot
+            plot_bgcolor='rgba(0,0,0,0)',   # White background inside the 3D plot
+    
+            margin = dict(l=0,r=0,t=0,b=0),
+
+            scene=dict(
+                aspectmode="manual",  # Allows custom aspect ratio
+                aspectratio=dict(x=1.15, y=1.15, z=1),  # Adjust scaling
+                xaxis=dict(
+                    title=dict(
+                        text="Temperature / K",
+                        font=dict(size=16, family="Arial", color="blue", weight='bold'),
+                    ),
+                    autorange="reversed", # This inverts the x-axis direction
+                    showgrid=True,
+                    zeroline=True,
+                    tickfont=dict(color="black", size=15,weight="bold"),
+                    tickangle=0,
+                    ticklen=10,
+                    tickwidth=2,
+                    ticks="outside",
+                    showbackground=False,  # Enable background to create a frame
+                    backgroundcolor="grey"  # Black frame
+                ),
+                yaxis=dict(
+                    title=dict(
+                        text="Pressure / bar",
+                        font=dict(size=16, family="Arial", color="blue", weight='bold'),
+                    ),
+                    tickangle=0,  # Rotate Y-axis ticks
+                    showgrid=True,
+                    zeroline=True,
+                    type='log',
+                    tickvals=log_tick_vals.tolist(),  # Set tick positions
+                    ticktext=log_tick_labels,  # Display ticks as 10^(-n)
+                    tickfont=dict(color="black", size=15,weight="bold"),
+                    ticklen=10,
+                    tickwidth=2,
+                    ticks="outside",
+                    showbackground=False,  # Enable background to create a frame
+                    backgroundcolor="grey"  # Black frame
+                ),
+                zaxis=dict(
+                    title="",  
+                    showgrid=False,
+                    zeroline=False,
+                    showticklabels=False,
+                    showbackground=False,  # Enable background to create a frame
+                    backgroundcolor="grey"  # Black frame
+                ),
+                camera=dict(
+                    eye=dict(x=1e-5, y=-1e-2, z=-1000),
+                    # eye=dict(x=1e-5, y=-1e-2, z=-1000),
+                    up=dict(x=0, y=1, z=0),
+                    projection=dict(type="orthographic")
+                ),
+            ),
+            legend=dict(
+                # y=0,
+                # x=0.2,
+                x = xLegend, y = yLegend,
+                font=dict(size=13, color="black"),
+                bgcolor="rgba(255, 255, 255, 1)",  # Light transparent background
+                bordercolor="grey",
+                borderwidth=1,
+                itemsizing='constant'
+            ),
+            showlegend=True
+        )
+
+        if saveFig is not None:
+            from .core import crop_images
+            # pngFile = os.path.join(folder_path, savedFig+".png")
+            # import plotly.io as pio
+            # fig.write_image(pngFile, format="png", width=1200, height=1200, scale=3)
+            pngFile = self.folder_path / f"{saveFig}.png"
+            fig.write_image(pngFile, format="png", width=1200, height=1200, scale=3)
+            # Automatic crop after saving
+            crop_images(pngFile)
+            
+        fig_widget = go.FigureWidget(fig)
+        fig_widget.show()
+        return fig_widget
+
+    def plot_palette(self, angle=0, save_png=None):
+        """
+        Visualize the 1D color palette used for surface identification.
+
+        This method generates a horizontal bar of colors corresponding to the 
+        different surface phases defined in the instance. Each color is labeled 
+        with its numerical index, allowing for quick cross-referencing between 
+        the palette and the 3D surface plot.
+
+        Args:
+            angle (int, optional): Rotation angle of the x-axis tick labels (indices). 
+                Defaults to 0.
+            save_png (str, optional): Filename (including .png extension) to save 
+                the palette image to the working directory. Defaults to None 
+                (display only).
+
+        Returns:
+            None: Displays the plot using matplotlib.pyplot.show().
+
+        Notes:
+            - Requires 'seaborn' for the palplot generation.
+            - If 'save_png' is provided, the image is saved with a resolution of 
+              300 DPI and a transparent background.
+        """
+        names = [str(i) for i in range(len(self.palette))]
+        sns.palplot(sns.color_palette(self.palette))
+        ax = plt.gca()
+        ax.set_xticks(np.arange(len(names)))
+        ax.set_xticklabels(names, weight='bold', size=10, rotation=angle)
+        
+        if save_png:
+            plt.tight_layout()
+            plt.savefig(self.folder_path / save_png, dpi=300, transparent=True)
+        plt.show()
+